add Benchmark (go) benchmark result for da8ec5f21d

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: [ lukaszraczylo ]
-custom: [ monzo.me/lukaszraczylo ]

.github/workflows/pr.yaml

@@ -1,89 +0,0 @@
-name: Run tests on PR
-
-on:
-  pull_request:
-    branches:
-      - "main"
-  push:
-    paths-ignore:
-      - "**/**.md"
-      - "**/**.yaml"
-      - "static/**"
-    branches:
-      - "!main"
-
-env:
-  GO_VERSION: ">=1.21"
-
-jobs:
-  # This job is responsible for preparation of the build
-  # environment variables.
-  prepare:
-    name: Preparing build context
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repo
-        uses: actions/checkout@v4
-
-      - name: Install Go
-        uses: actions/setup-go@v5
-        id: cache
-        with:
-          go-version: ${{env.GO_VERSION}}
-          cache-dependency-path: "**/*.sum"
-
-      - name: Go get dependencies
-        if: steps.cache.outputs.cache-hit != 'true'
-        run: |
-          go get ./...
-
-  # This job is responsible for running tests and linting the codebase
-  test:
-    name: "Unit testing"
-    # needs: [prepare]
-    runs-on: ubuntu-latest
-    container: golang:1
-    # container: github/super-linter:v4
-    needs: [prepare]
-
-    services:
-      # Label used to access the service container
-      redis:
-        # Docker Hub image
-        image: redis
-        # Set health checks to wait until redis has started
-        options: >-
-          --health-cmd "redis-cli ping"
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-        ports:
-          # Maps the container port to the host machine
-          - 6379:6379
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Install Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: ${{env.GO_VERSION}}
-          cache-dependency-path: "**/*.sum"
-
-      - name: Install dependencies
-        run: |
-          apt-get update
-          apt-get install ca-certificates make -y
-          update-ca-certificates
-          go mod tidy
-
-      - name: Run unit tests
-        env:
-          REDIS_HOST: redis
-          REDIS_PORT: 6379
-          REDIS_SERVER: "redis:6379"
-        run: |
-          export REDIS_SERVER="$REDIS_HOST:$REDIS_PORT"
-          CI_RUN=${CI} make test

.github/workflows/test.yaml

@@ -1,20 +0,0 @@
-name: Test and release
-
-on:
-  workflow_dispatch:
-  push:
-    paths-ignore:
-    - '**/**.md'
-    - '**/**.yaml'
-    - 'static/**'
-    branches:
-    - 'main'
-
-jobs:
-  shared:
-    uses: telegram-bot-app/ci-scripts/.github/workflows/build-test-publish-inject.yaml@main
-    with:
-      enable-code-scans: false
-      should-deploy: false
-    secrets:
-      ghcr-token: ${{ secrets.GHCR_TOKEN }}

.gitignore

@@ -1,2 +1,3 @@
 graphql-proxy
 test.sh
+banned.json*

Dockerfile

@@ -1,8 +0,0 @@
-FROM gcr.io/distroless/base-debian12:nonroot
-WORKDIR /go/src/app
-ARG TARGETARCH
-ARG TARGETOS
-# silly workaround for distroless image as no chmod is available
-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"]

LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Lukasz Raczylo
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

Makefile

@@ -1,34 +0,0 @@
-CI_RUN?=false
-ADDITIONAL_BUILD_FLAGS=""
-
-ifeq ($(CI_RUN), true)
-	ADDITIONAL_BUILD_FLAGS="-test.short"
-endif
-
-.PHONY: help
-help:  ## display this help
-	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m<target>\033[0m\n\nTargets:\n"} /^[a-zA-Z0-9_-]+:.*?##/ { printf "  \033[36m%-20s\033[0m %s\n", $$1, $$2 }' $(MAKEFILE_LIST)
-
-.PHONY: run
-run: build ## run application
-	@LOG_LEVEL=debug PURGE_METRICS_ON_CRAWL=true BLOCK_SCHEMA_INTROSPECTION=false CACHE_TTL=10 JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ HEALTHCHECK_GRAPHQL_URL=https://hasura8.lan/v1/graphql ./graphql-proxy
-
-.PHONY: build
-build: ## build the binary
-	go build -o graphql-proxy *.go
-
-.PHONY: test
-test: ## run tests on library
-	@LOG_LEVEL=debug go test $(ADDITIONAL_BUILD_FLAGS) -v -cover ./... -race
-
-.PHONY: test-packages
-test-packages: ## run tests on packages
-	@go test -v -cover ./pkg/...
-
-.PHONY: all
-all: test-packages test
-
-.PHONY: update
-update: ## update dependencies
-	@go get -u -v ./...
-	@go mod tidy -v

README.md

@@ -2,7 +2,7 @@
 
 Creates a passthrough proxy to a graphql endpoint(s), allowing you to analyse the queries and responses, producing the Prometheus metrics at a fraction of the cost - because, as we know - $0 is a fair price.
 
-This project is in active use by [telegram-bot.app](https://telegram-bot.app), and was tested with 30k queries per second on a single instance, consuming 10 MB of RAM and 0.1% CPU.
+This project is in active use by [telegram-bot.app](https://telegram-bot.app), and was tested with 30k queries per second on a single instance, consuming 10 MB of RAM and 0.1% CPU. [Benchmarks](https://lukaszraczylo.github.io/graphql-monitoring-proxy/dev/bench/) are available.
 
 ![Example of monitoring dashboard](static/monitoring-at-glance.png?raw=true)
 

api.go

@@ -1,161 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	"github.com/goccy/go-json"
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/gofrs/flock"
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-)
-
-var bannedUsersIDs map[string]string = make(map[string]string)
-
-func enableApi() {
-	if cfg.Server.EnableApi {
-		apiserver := fiber.New(fiber.Config{
-			DisableStartupMessage: true,
-			AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
-		})
-
-		api := apiserver.Group("/api")
-		api.Post("/user-ban", apiBanUser)
-		api.Post("/user-unban", apiUnbanUser)
-		api.Post("/cache-clear", apiClearCache)
-		api.Get("/cache-stats", apiCacheStats)
-
-		go periodicallyReloadBannedUsers()
-		err := apiserver.Listen(fmt.Sprintf(":%d", cfg.Server.ApiPort))
-		if err != nil {
-			cfg.Logger.Critical("Can't start the service", map[string]interface{}{"error": err.Error()})
-		}
-	}
-}
-
-func periodicallyReloadBannedUsers() {
-	for {
-		loadBannedUsers()
-		cfg.Logger.Debug("Banned users reloaded", map[string]interface{}{"users": bannedUsersIDs})
-		<-time.After(10 * time.Second)
-	}
-}
-
-func checkIfUserIsBanned(c *fiber.Ctx, userID string) bool {
-	_, found := bannedUsersIDs[userID]
-	cfg.Logger.Debug("Checking if user is banned", map[string]interface{}{"user_id": userID, "found": found})
-	if found {
-		cfg.Logger.Info("User is banned", map[string]interface{}{"user_id": userID})
-		c.Status(403).SendString("User is banned")
-	}
-	return found
-}
-
-func apiClearCache(c *fiber.Ctx) error {
-	cfg.Logger.Debug("Clearing cache via API", nil)
-	cacheClear()
-	cfg.Logger.Info("Cache cleared via API", nil)
-	c.Status(200).SendString("OK: cache cleared")
-	return nil
-}
-
-func apiCacheStats(c *fiber.Ctx) error {
-	stats := getCacheStats()
-	cfg.Logger.Debug("Getting cache stats via API", map[string]interface{}{"stats": stats})
-	err := c.JSON(stats)
-	if err != nil {
-		cfg.Logger.Error("Can't marshal cache stats", map[string]interface{}{"error": err.Error()})
-		return err
-	}
-	return nil
-}
-
-type apiBanUserRequest struct {
-	UserID string `json:"user_id"`
-	Reason string `json:"reason"`
-}
-
-func apiBanUser(c *fiber.Ctx) error {
-	var req apiBanUserRequest
-	err := c.BodyParser(&req)
-	if err != nil {
-		cfg.Logger.Error("Can't parse the ban user request", map[string]interface{}{"error": err.Error()})
-		return err
-	}
-	bannedUsersIDs[req.UserID] = req.Reason
-	cfg.Logger.Info("Banned user", map[string]interface{}{"user_id": req.UserID, "reason": req.Reason})
-	storeBannedUsers()
-	c.Status(200).SendString("OK: user banned")
-	return nil
-}
-
-func apiUnbanUser(c *fiber.Ctx) error {
-	var req apiBanUserRequest
-	err := c.BodyParser(&req)
-	if err != nil {
-		cfg.Logger.Error("Can't parse the unban user request", map[string]interface{}{"error": err.Error()})
-		return err
-	}
-	delete(bannedUsersIDs, req.UserID)
-	cfg.Logger.Info("Unbanned user", map[string]interface{}{"user_id": req.UserID})
-	storeBannedUsers()
-	c.Status(200).SendString("OK: user unbanned")
-	return nil
-}
-
-func storeBannedUsers() {
-	fileLock := flock.New(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	err := fileLock.Lock()
-	if err != nil {
-		cfg.Logger.Error("Can't lock the file", map[string]interface{}{"error": err.Error()})
-		return
-	}
-	defer fileLock.Unlock()
-	data, err := json.Marshal(bannedUsersIDs)
-	if err != nil {
-		cfg.Logger.Error("Can't marshal banned users", map[string]interface{}{"error": err.Error()})
-		return
-	}
-	err = os.WriteFile(cfg.Api.BannedUsersFile, data, 0644)
-	if err != nil {
-		cfg.Logger.Error("Can't write banned users to file", map[string]interface{}{"error": err.Error()})
-		return
-	}
-}
-
-func loadBannedUsers() {
-	if _, err := os.Stat(cfg.Api.BannedUsersFile); os.IsNotExist(err) {
-		cfg.Logger.Info("Banned users file doesn't exist - creating it", map[string]interface{}{"file": cfg.Api.BannedUsersFile})
-		_, err := os.Create(cfg.Api.BannedUsersFile)
-		if err != nil {
-			cfg.Logger.Error("Can't create the file", map[string]interface{}{"error": err.Error()})
-			return
-		}
-		// write empty json to the file
-		err = os.WriteFile(cfg.Api.BannedUsersFile, []byte("{}"), 0644)
-		if err != nil {
-			cfg.Logger.Error("Can't write to the file", map[string]interface{}{"error": err.Error()})
-			return
-		}
-	}
-
-	fileLock := flock.New(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	err := fileLock.RLock() // Use RLock for read lock
-	if err != nil {
-		cfg.Logger.Error("Can't lock the file [load]", map[string]interface{}{"error": err.Error()})
-		return
-	}
-	defer fileLock.Unlock()
-
-	data, err := os.ReadFile(cfg.Api.BannedUsersFile)
-	if err != nil {
-		cfg.Logger.Error("Can't read banned users from file", map[string]interface{}{"error": err.Error()})
-		return
-	}
-	err = json.Unmarshal(data, &bannedUsersIDs)
-	if err != nil {
-		cfg.Logger.Error("Can't unmarshal banned users", map[string]interface{}{"error": err.Error()})
-		return
-	}
-}

cache.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"time"
-
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/gookit/goutil/strutil"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_redis "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/redis"
-)
-
-type CacheStats struct {
-	CachedQueries int `json:"cached_queries"`
-	CacheHits     int `json:"cache_hits"`
-	CacheMisses   int `json:"cache_misses"`
-}
-
-type CacheClient interface {
-	Set(key string, value []byte, ttl time.Duration)
-	Get(key string) ([]byte, bool)
-	Delete(key string)
-	Clear()
-	CountQueries() int
-}
-
-var (
-	cacheStats *CacheStats
-)
-
-func calculateHash(c *fiber.Ctx) string {
-	return strutil.Md5(c.Body())
-}
-
-func enableCache() {
-	cacheStats = &CacheStats{}
-	if shouldUseRedisCache() {
-		cfg.Logger.Info("Using Redis cache", nil)
-		cfg.Cache.Client = libpack_redis.NewClient(&libpack_redis.RedisClientConfig{
-			RedisDB:       cfg.Cache.CacheRedisDB,
-			RedisServer:   cfg.Cache.CacheRedisURL,
-			RedisPassword: cfg.Cache.CacheRedisPassword,
-		})
-	} else {
-		cfg.Logger.Info("Using in-memory cache", nil)
-		cfg.Cache.Client = libpack_cache.New(time.Duration(cfg.Cache.CacheTTL) * time.Second)
-	}
-}
-
-func cacheLookup(hash string) []byte {
-	obj, found := cfg.Cache.Client.Get(hash)
-	if found {
-		cacheStats.CacheHits++
-		return obj
-	}
-	cacheStats.CacheMisses++
-	return nil
-}
-
-func cacheDelete(hash string) {
-	cfg.Logger.Debug("Deleting data from cache", map[string]interface{}{"hash": hash})
-	cacheStats.CachedQueries--
-	cfg.Cache.Client.Delete(hash)
-}
-
-func cacheStore(hash string, data []byte) {
-	cfg.Logger.Debug("Storing data in cache", map[string]interface{}{"hash": hash})
-	cacheStats.CachedQueries++
-	cfg.Cache.Client.Set(hash, data, time.Duration(cfg.Cache.CacheTTL)*time.Second)
-}
-
-func cacheStoreWithTTL(hash string, data []byte, ttl time.Duration) {
-	cfg.Logger.Debug("Storing data in cache with TTL", map[string]interface{}{"hash": hash, "ttl": ttl})
-	cacheStats.CachedQueries++
-	cfg.Cache.Client.Set(hash, data, ttl)
-}
-
-func cacheGetQueries() int {
-	cfg.Logger.Debug("Counting cache queries", nil)
-	return cfg.Cache.Client.CountQueries()
-}
-
-func cacheClear() {
-	cfg.Cache.Client.Clear()
-	cacheStats = &CacheStats{}
-}
-
-func getCacheStats() *CacheStats {
-	cfg.Logger.Debug("Getting cache stats", nil)
-	cacheStats.CachedQueries = cacheGetQueries()
-	return cacheStats
-}
-
-func shouldUseRedisCache() bool {
-	return cfg.Cache.CacheRedisEnable
-}

cache/memory/cache.go

@@ -1,186 +0,0 @@
-package libpack_cache
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-	"log"
-	"sync"
-	"time"
-)
-
-type CacheEntry struct {
-	ExpiresAt time.Time
-	Value     []byte
-}
-
-type Cache struct {
-	compressPool   sync.Pool
-	decompressPool sync.Pool
-	entries        sync.Map
-	globalTTL      time.Duration
-	mu             sync.RWMutex // Added sync.RWMutex field for locking
-}
-
-func New(globalTTL time.Duration) *Cache {
-	cache := &Cache{
-		globalTTL: globalTTL,
-		compressPool: sync.Pool{
-			New: func() interface{} {
-				return gzip.NewWriter(nil)
-			},
-		},
-		decompressPool: sync.Pool{
-			New: func() interface{} {
-				r, _ := gzip.NewReader(bytes.NewReader([]byte{}))
-				return r
-			},
-		},
-	}
-
-	go cache.cleanupRoutine(globalTTL)
-	return cache
-}
-
-func (c *Cache) cleanupRoutine(globalTTL time.Duration) {
-	ticker := time.NewTicker(globalTTL / 2)
-	defer ticker.Stop()
-
-	for range ticker.C {
-		c.CleanExpiredEntries()
-	}
-}
-
-func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
-	c.lock()
-	defer c.unlock()
-
-	expiresAt := time.Now().Add(ttl)
-
-	compressedValue, err := c.compress(value)
-	if err != nil {
-		log.Printf("Error compressing value for key %s: %v", key, err)
-		return
-	}
-
-	entry := CacheEntry{
-		Value:     compressedValue,
-		ExpiresAt: expiresAt,
-	}
-	c.entries.Store(key, entry)
-}
-
-func (c *Cache) Get(key string) ([]byte, bool) {
-	c.rlock()
-	defer c.runlock()
-
-	entry, ok := c.entries.Load(key)
-	if !ok || entry.(CacheEntry).ExpiresAt.Before(time.Now()) {
-		return nil, false
-	}
-	compressedValue := entry.(CacheEntry).Value
-	value, err := c.decompress(compressedValue)
-	if err != nil {
-		log.Printf("Error decompressing value for key %s: %v", key, err)
-		return nil, false
-	}
-	return value, true
-}
-
-func (c *Cache) Delete(key string) {
-	c.lock()
-	defer c.unlock()
-
-	c.entries.Delete(key)
-}
-
-func (c *Cache) Clear() {
-	c.lock()
-	defer c.unlock()
-
-	c.entries.Range(func(key, value interface{}) bool {
-		c.entries.Delete(key)
-		return true
-	})
-}
-
-func (c *Cache) CountQueries() int {
-	c.rlock()
-	defer c.runlock()
-
-	var count int
-	c.entries.Range(func(_, _ interface{}) bool {
-		count++
-		return true
-	})
-	return count
-}
-
-func (c *Cache) compress(data []byte) ([]byte, error) {
-	w := c.compressPool.Get().(*gzip.Writer)
-	defer c.compressPool.Put(w)
-
-	var buf bytes.Buffer
-	w.Reset(&buf)
-	if _, err := w.Write(data); err != nil {
-		return nil, err
-	}
-	if err := w.Close(); err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-func (c *Cache) decompress(data []byte) ([]byte, error) {
-	r, ok := c.decompressPool.Get().(*gzip.Reader)
-	if !ok || r == nil {
-		var err error
-		r, err = gzip.NewReader(bytes.NewReader(data))
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		if err := r.Reset(bytes.NewReader(data)); err != nil {
-			return nil, err
-		}
-	}
-	defer func() {
-		r.Close()
-		c.decompressPool.Put(r)
-	}()
-
-	decompressedData, err := io.ReadAll(r)
-	if err != nil {
-		return nil, err
-	}
-	return decompressedData, nil
-}
-
-func (c *Cache) CleanExpiredEntries() {
-	now := time.Now()
-	c.entries.Range(func(key, value interface{}) bool {
-		entry := value.(CacheEntry)
-		if entry.ExpiresAt.Before(now) {
-			c.entries.Delete(key)
-		}
-		return true
-	})
-}
-
-// Private methods to handle locking
-
-func (c *Cache) lock() {
-	c.mu.Lock()
-}
-
-func (c *Cache) unlock() {
-	c.mu.Unlock()
-}
-
-func (c *Cache) rlock() {
-	c.mu.RLock()
-}
-
-func (c *Cache) runlock() {
-	c.mu.RUnlock()
-}

cache/memory/cache_bench_test.go

@@ -1,54 +0,0 @@
-package libpack_cache
-
-import (
-	"testing"
-	"time"
-)
-
-// Assume that New function initializes the cache and it is defined somewhere in the libpack_cache package.
-
-func BenchmarkCacheSet(b *testing.B) {
-	cache := New(30 * time.Second) // Initializing the cache with a TTL of 30 seconds
-	key := "benchmark-key"
-	value := []byte("benchmark-value")
-
-	b.ResetTimer() // Reset the timer to exclude the setup time from the benchmark
-
-	for i := 0; i < b.N; i++ {
-		cache.Set(key, value, 5*time.Second)
-	}
-}
-
-func BenchmarkCacheGet(b *testing.B) {
-	cache := New(30 * time.Second) // Initializing the cache
-	key := "benchmark-key"
-	value := []byte("benchmark-value")
-	cache.Set(key, value, 5*time.Second) // Pre-set a value to retrieve
-
-	b.ResetTimer() // Start timing
-
-	for i := 0; i < b.N; i++ {
-		_, _ = cache.Get(key)
-	}
-}
-
-func BenchmarkCacheExpire(b *testing.B) {
-	key := "benchmark-expire-key"
-	value := []byte("benchmark-value")
-	ttl := 5 * time.Millisecond // Setting a short TTL for quick expiration
-
-	for i := 0; i < b.N; i++ {
-		cache := New(30 * time.Second)
-		cache.Set(key, value, ttl)
-		time.Sleep(ttl) // Wait for the key to expire
-		_, _ = cache.Get(key)
-	}
-}
-
-func BenchmarkCacheStats(b *testing.B) {
-	cache := New(30 * time.Second) // Initializing the cache
-	key := "benchmark-key"
-	value := []byte("benchmark-value")
-	cache.Set(key, value, 5*time.Second) // Pre-set a value to retrieve
-	cache.Get(key)
-}

cache/memory/cache_test.go

@@ -1,112 +0,0 @@
-package libpack_cache
-
-import (
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/suite"
-)
-
-type CacheTestSuite struct {
-	suite.Suite
-}
-
-func (suite *CacheTestSuite) SetupTest() {
-}
-
-func TestCachingTestSuite(t *testing.T) {
-	suite.Run(t, new(CacheTestSuite))
-}
-
-func (suite *CacheTestSuite) Test_New() {
-	suite.T().Run("should return a new cache", func(t *testing.T) {
-		cache := New(2 * time.Second)
-		suite.NotNil(cache)
-	})
-}
-
-func (suite *CacheTestSuite) Test_CacheUse() {
-	cache := New(30 * time.Second)
-	tests := []struct {
-		name        string
-		cache_value string
-	}{
-		{
-			name:        "test1",
-			cache_value: "test1-123",
-		},
-		{
-			name:        "test2",
-			cache_value: "test2-123",
-		},
-	}
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			cache.Set(tt.name, []byte(tt.name), 5*time.Second)
-			c, ok := cache.Get(tt.name)
-			suite.Equal(true, ok)
-			suite.Equal(tt.name, string(c))
-		})
-	}
-}
-
-func (suite *CacheTestSuite) Test_CacheDelete() {
-	cache := New(30 * time.Second)
-	tests := []struct {
-		name        string
-		cache_value string
-	}{
-		{
-			name:        "test1",
-			cache_value: "test1-123",
-		},
-		{
-			name:        "test2",
-			cache_value: "test2-123",
-		},
-	}
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			cache.Set(tt.name, []byte(tt.name), 5*time.Second)
-			c, ok := cache.Get(tt.name)
-			suite.Equal(true, ok)
-			suite.Equal(tt.name, string(c))
-			cache.Delete(tt.name)
-			c, ok = cache.Get(tt.name)
-			suite.Equal(false, ok)
-			suite.Equal("", string(c))
-		})
-	}
-}
-
-func (suite *CacheTestSuite) Test_CacheExpire() {
-	cache := New(30 * time.Second)
-	tests := []struct {
-		name        string
-		cache_value string
-		ttl         time.Duration
-	}{
-		{
-			name:        "test1",
-			cache_value: "test1-123",
-			ttl:         2 * time.Second,
-		},
-		{
-			name:        "test2",
-			cache_value: "test2-123",
-			ttl:         5 * time.Second,
-		},
-	}
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			cache.Set(tt.name, []byte(tt.name), tt.ttl)
-			c, ok := cache.Get(tt.name)
-			suite.Equal(true, ok)
-			suite.Equal(tt.name, string(c))
-			time.Sleep(tt.ttl)
-			c, ok = cache.Get(tt.name)
-			suite.Equal(false, ok)
-			suite.Equal("", string(c))
-		})
-	}
-}

cache/redis/connection.go

@@ -1,77 +0,0 @@
-package libpack_redis
-
-import (
-	"context"
-	"time"
-
-	redis "github.com/redis/go-redis/v9"
-)
-
-var ()
-
-type RedisConfig struct {
-	client *redis.Client
-	ctx    context.Context
-}
-
-func prependKeyName(key string) string {
-	return "gmp_cache:" + key
-}
-
-type RedisClientConfig struct {
-	RedisServer   string
-	RedisPassword string
-	RedisDB       int
-}
-
-func NewClient(redisClientConfig *RedisClientConfig) *RedisConfig {
-	c := &RedisConfig{
-		client: redis.NewClient(&redis.Options{
-			Addr:     redisClientConfig.RedisServer,
-			Password: redisClientConfig.RedisPassword,
-			DB:       redisClientConfig.RedisDB,
-		}),
-		ctx: context.Background(),
-	}
-	_, err := c.client.Ping(c.ctx).Result()
-	if err != nil {
-		panic(err)
-	}
-	return c
-}
-
-func (c *RedisConfig) Set(key string, value []byte, ttl time.Duration) {
-	c.client.Set(c.ctx, prependKeyName(key), value, ttl)
-}
-
-func (c *RedisConfig) Get(key string) ([]byte, bool) {
-	val, err := c.client.Get(c.ctx, prependKeyName(key)).Result()
-	if err == redis.Nil || err != nil {
-		return nil, false
-	}
-	return []byte(val), true
-}
-
-func (c *RedisConfig) Delete(key string) {
-	c.client.Del(c.ctx, prependKeyName(key))
-}
-
-func (c *RedisConfig) Clear() {
-	c.client.FlushDB(c.ctx)
-}
-
-func (c *RedisConfig) CountQueries() int {
-	keys, err := c.client.Keys(c.ctx, prependKeyName("*")).Result()
-	if err != nil {
-		return 0
-	}
-	return len(keys)
-}
-
-func (c *RedisConfig) CountQueriesWithPattern(pattern string) int {
-	keys, err := c.client.Keys(c.ctx, prependKeyName(pattern)).Result()
-	if err != nil {
-		return 0
-	}
-	return len(keys)
-}

cache/redis/connection_test.go

@@ -1,125 +0,0 @@
-package libpack_redis
-
-import (
-	"testing"
-	"time"
-
-	"github.com/gookit/goutil/envutil"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type RedisConfigSuite struct {
-	suite.Suite
-	redisConfig *RedisConfig
-}
-
-func (suite *RedisConfigSuite) SetupTest() {
-	redis_server := envutil.Getenv("REDIS_SERVER", "localhost:6379")
-	suite.redisConfig = NewClient(&RedisClientConfig{
-		RedisServer:   redis_server,
-		RedisPassword: "",
-		RedisDB:       0,
-	})
-	suite.redisConfig.Delete("testkey")
-}
-
-func TestRedisConfigSuite(t *testing.T) {
-	suite.Run(t, new(RedisConfigSuite))
-}
-
-func (suite *RedisConfigSuite) TestSet() {
-	key := "testkey"
-	value := []byte("testvalue")
-	suite.redisConfig.Delete(key) // Ensure the key is deleted before the test
-
-	// Test writing a new key-value pair
-	suite.redisConfig.Set(key, value, 0)
-	storedValue, found := suite.redisConfig.Get(key)
-	assert.True(suite.T(), found)
-	assert.Equal(suite.T(), value, storedValue)
-
-	// Test overwriting an existing key-value pair
-	newValue := []byte("newvalue")
-	suite.redisConfig.Set(key, newValue, 0)
-	storedValue, found = suite.redisConfig.Get(key)
-	assert.True(suite.T(), found)
-	assert.Equal(suite.T(), newValue, storedValue)
-
-	suite.redisConfig.Delete(key) // Clean up after the test
-}
-
-func (suite *RedisConfigSuite) TestSetWithExpiry() {
-	key := "testkey"
-	value := []byte("testvalue")
-	expiry := 1 * time.Second
-	suite.redisConfig.Delete(key) // Ensure the key is deleted before the test
-
-	// Test writing a new key-value pair
-	suite.redisConfig.Set(key, value, expiry)
-	storedValue, found := suite.redisConfig.Get(key)
-	assert.True(suite.T(), found)
-	assert.Equal(suite.T(), value, storedValue)
-
-	// Test that key expires after the specified time
-	time.Sleep(2 * time.Second)
-	_, found = suite.redisConfig.Get(key)
-	assert.False(suite.T(), found)
-
-	suite.redisConfig.Delete(key) // Clean up after the test
-}
-
-func (suite *RedisConfigSuite) TestGet() {
-	key := "testkey"
-	value := []byte("testvalue")
-	suite.redisConfig.Set(key, value, 0) // Set the key-value pair
-	storedValue, found := suite.redisConfig.Get(key)
-	assert.True(suite.T(), found)
-	assert.Equal(suite.T(), value, storedValue)
-}
-
-func (suite *RedisConfigSuite) TestDeleteKey() {
-	key := "testkey"
-	value := []byte("testvalue")
-	suite.redisConfig.Set(key, value, 0) // Set the key-value pair
-	suite.redisConfig.Delete(key)
-	_, found := suite.redisConfig.Get(key)
-	assert.False(suite.T(), found)
-}
-
-func (suite *RedisConfigSuite) TestCheckIfKeyExists() {
-	ttl := time.Duration(10) * time.Second
-	key := "testkey"
-	value := []byte("testvalue")
-	suite.redisConfig.Set(key, value, ttl) // Set the key-value pair
-	_, found := suite.redisConfig.Get(key)
-	assert.True(suite.T(), found)
-
-	suite.redisConfig.Delete(key)
-	_, found = suite.redisConfig.Get(key)
-	assert.False(suite.T(), found)
-}
-
-func (suite *RedisConfigSuite) TestGetKeys() {
-	ttl := time.Duration(10) * time.Second
-	suite.redisConfig.Set("testkey1", []byte("testvalue1"), ttl)
-	suite.redisConfig.Set("testkey2", []byte("testvalue2"), ttl)
-	suite.redisConfig.Set("otherkey", []byte("othervalue"), ttl)
-
-	keys, _ := suite.redisConfig.client.Keys(suite.redisConfig.ctx, prependKeyName("testkey*")).Result()
-	expectedKeys := []string{prependKeyName("testkey1"), prependKeyName("testkey2")}
-	assert.ElementsMatch(suite.T(), expectedKeys, keys)
-
-	suite.redisConfig.client.Del(suite.redisConfig.ctx, "testkey1", "testkey2", "otherkey")
-}
-
-func (suite *RedisConfigSuite) TestGetKeysCount() {
-	ttl := time.Duration(10) * time.Second
-	suite.redisConfig.Set("testkey1", []byte("testvalue1"), ttl)
-	suite.redisConfig.Set("testkey2", []byte("testvalue2"), ttl)
-	suite.redisConfig.Set("otherkey", []byte("othervalue"), ttl)
-
-	assert.Equal(suite.T(), 2, suite.redisConfig.CountQueriesWithPattern("testkey*"))
-
-	suite.redisConfig.client.Del(suite.redisConfig.ctx, "testkey1", "testkey2", "otherkey")
-}

cache_test.go

@@ -1,99 +0,0 @@
-package main
-
-import (
-	"github.com/gookit/goutil/envutil"
-	libpack_redis "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/redis"
-)
-
-func (suite *Tests) Test_cacheLookupInmemory() {
-	type args struct {
-		hash string
-	}
-	tests := []struct {
-		name     string
-		args     args
-		want     []byte
-		addCache struct {
-			data []byte
-		}
-	}{
-		{
-			name: "test_non_existent",
-			args: args{
-				hash: "00000000000000000000000000000000000000",
-			},
-			want: nil,
-		},
-		{
-			name: "test_existent",
-			args: args{
-				hash: "00000000000000000000000000000000001337",
-			},
-			want: []byte("it's fine."),
-			addCache: struct {
-				data []byte
-			}{
-				data: []byte("it's fine."),
-			},
-		},
-	}
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			if tt.addCache.data != nil {
-				cacheStore(tt.args.hash, tt.addCache.data)
-			}
-			got := cacheLookup(tt.args.hash)
-			assert.Equal(tt.want, got, "Unexpected cache lookup result")
-		})
-	}
-}
-
-func (suite *Tests) Test_cacheLookupRedis() {
-	redis_server := envutil.Getenv("REDIS_SERVER", "localhost:6379")
-	cfg.Cache.Client = libpack_redis.NewClient(&libpack_redis.RedisClientConfig{
-		RedisServer:   redis_server,
-		RedisPassword: "",
-		RedisDB:       0,
-	})
-
-	type args struct {
-		hash string
-	}
-	tests := []struct {
-		name     string
-		args     args
-		want     []byte
-		addCache struct {
-			data []byte
-		}
-	}{
-		{
-			name: "test_non_existent",
-			args: args{
-				hash: "00000000000000000000000000000000000000",
-			},
-			want: nil,
-		},
-		{
-			name: "test_existent",
-			args: args{
-				hash: "00000000000000000000000000000000001337",
-			},
-			want: []byte("it's fine."),
-			addCache: struct {
-				data []byte
-			}{
-				data: []byte("it's fine."),
-			},
-		},
-	}
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			if tt.addCache.data != nil {
-				cacheStore(tt.args.hash, tt.addCache.data)
-			}
-			got := cacheLookup(tt.args.hash)
-			assert.Equal(tt.want, got, "Unexpected cache lookup result")
-		})
-	}
-}

config/config.go

@@ -1,6 +0,0 @@
-package libpack_config
-
-var (
-	PKG_NAME    string = "not-specified"
-	PKG_VERSION string = "0.0.0-dev"
-)

details.go

@@ -1,53 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"fmt"
-	"strings"
-
-	"github.com/goccy/go-json"
-	"github.com/lukaszraczylo/ask"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-)
-
-func extractClaimsFromJWTHeader(authorization string) (usr string, role string) {
-	usr, role = "-", "-"
-
-	handleError := func(msg string, details map[string]interface{}) {
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		cfg.Logger.Error(msg, details)
-	}
-
-	tokenParts := strings.Split(authorization, ".")
-	if len(tokenParts) != 3 {
-		handleError("Can't split the token", map[string]interface{}{"token": authorization})
-		return
-	}
-
-	claim, err := base64.RawURLEncoding.DecodeString(tokenParts[1])
-	if err != nil {
-		handleError("Can't decode the token", map[string]interface{}{"token": authorization})
-		return
-	}
-
-	var claimMap map[string]interface{}
-	if err = json.Unmarshal(claim, &claimMap); err != nil {
-		handleError("Can't unmarshal the claim", map[string]interface{}{"token": authorization})
-		return
-	}
-
-	extractClaim := func(claimPath string, target *string, name string) {
-		if len(claimPath) > 0 {
-			var ok bool
-			*target, ok = ask.For(claimMap, claimPath).String("-")
-			if !ok {
-				handleError(fmt.Sprintf("Can't find the %s", name), map[string]interface{}{"claim_map": claimMap, "path": claimPath})
-			}
-		}
-	}
-
-	extractClaim(cfg.Client.JWTUserClaimPath, &usr, "user id")
-	extractClaim(cfg.Client.JWTRoleClaimPath, &role, "role")
-
-	return
-}

details_test.go

@@ -1,81 +0,0 @@
-package main
-
-func (suite *Tests) Test_extractClaimsFromJWTHeader() {
-	jwt_token_for_tests := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiSGFzdXJhIjp7IngtaGFzdXJhLWFsbG93ZWQtcm9sZXMiOlsiZ3Vlc3QiLCJ1c2VyIiwiZ3JvdXBhZG1pbiIsInBheWFkbWluIl0sIngtaGFzdXJhLWRlZmF1bHQtcm9sZSI6Imd1ZXN0IiwieC1oYXN1cmEtdXNlci1pZCI6IjE2NyIsIngtaGFzdXJhLXVzZXItdXVpZCI6ImRkM2U2ZTM1LTA0MDktNDNiMC1iZmYxLWNlZjNjNmVkNWYxMCJ9LCJpc3MiOiJBdXRoU2VydmljZSIsImV4cCI6MTY5NjgwMTcyNiwibmJmIjoxNjk2NTg1NzI2LCJpYXQiOjE2OTY1ODU3MjZ9.dsJ5JKzG5tXOlqeZ_Gfe2XC-vyrcwtYwOGfhvt8q9UY"
-
-	type args struct {
-		authorization string
-	}
-
-	tests := []struct {
-		name           string
-		args           args
-		wantUsr        string
-		wantRole       string
-		jwt_token_path string
-		jwt_role_path  string
-	}{
-		{
-			name:     "test_empty",
-			wantUsr:  "-",
-			wantRole: "-",
-		},
-		{
-			name: "test_invalid_path",
-			args: args{
-				authorization: jwt_token_for_tests,
-			},
-			wantUsr:        "-",
-			wantRole:       "-",
-			jwt_token_path: "invalid",
-		},
-		{
-			name: "test_invalid_role_path",
-			args: args{
-				authorization: jwt_token_for_tests,
-			},
-			wantUsr:       "-",
-			wantRole:      "-",
-			jwt_role_path: "invalid",
-		},
-		{
-			name: "test_valid",
-			args: args{
-				authorization: jwt_token_for_tests,
-			},
-			wantUsr:        "167",
-			wantRole:       "guest",
-			jwt_token_path: "Hasura.x-hasura-user-id",
-			jwt_role_path:  "Hasura.x-hasura-default-role",
-		},
-		{
-			name: "test_invalid_token",
-			args: args{
-				authorization: "invalid",
-			},
-			wantUsr:  "-",
-			wantRole: "-",
-		},
-		{
-			name: "test_invalid_three_part_token",
-			args: args{
-				authorization: "invalid.threepart.token",
-			},
-			wantUsr:  "-",
-			wantRole: "-",
-		},
-	}
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			if len(tt.jwt_token_path) > 0 {
-				cfg.Client.JWTUserClaimPath = tt.jwt_token_path
-			}
-			if len(tt.jwt_role_path) > 0 {
-				cfg.Client.JWTRoleClaimPath = tt.jwt_role_path
-			}
-			gotUsr, gotRole := extractClaimsFromJWTHeader(tt.args.authorization)
-			assert.Equal(tt.wantUsr, gotUsr, "Unexpected user ID")
-			assert.Equal(tt.wantRole, gotRole, "Unexpected role")
-		})
-	}
-}

docs/index.html

@@ -0,0 +1,281 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1, user-scalable=yes" />
+    <style>
+      html {
+        font-family: BlinkMacSystemFont,-apple-system,"Segoe UI",Roboto,Oxygen,Ubuntu,Cantarell,"Fira Sans","Droid Sans","Helvetica Neue",Helvetica,Arial,sans-serif;
+        -webkit-font-smoothing: antialiased;
+        background-color: #fff;
+        font-size: 16px;
+      }
+      body {
+        color: #4a4a4a;
+        margin: 8px;
+        font-size: 1em;
+        font-weight: 400;
+      }
+      header {
+        margin-bottom: 8px;
+        display: flex;
+        flex-direction: column;
+      }
+      main {
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+      }
+      a {
+        color: #3273dc;
+        cursor: pointer;
+        text-decoration: none;
+      }
+      a:hover {
+        color: #000;
+      }
+      button {
+        color: #fff;
+        background-color: #3298dc;
+        border-color: transparent;
+        cursor: pointer;
+        text-align: center;
+      }
+      button:hover {
+        background-color: #2793da;
+        flex: none;
+      }
+      .spacer {
+        flex: auto;
+      }
+      .small {
+        font-size: 0.75rem;
+      }
+      footer {
+        margin-top: 16px;
+        display: flex;
+        align-items: center;
+      }
+      .header-label {
+        margin-right: 4px;
+      }
+      .benchmark-set {
+        margin: 8px 0;
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+      }
+      .benchmark-title {
+        font-size: 3rem;
+        font-weight: 600;
+        word-break: break-word;
+        text-align: center;
+      }
+      .benchmark-graphs {
+        display: flex;
+        flex-direction: row;
+        justify-content: space-around;
+        align-items: center;
+        flex-wrap: wrap;
+        width: 100%;
+      }
+      .benchmark-chart {
+        max-width: 1000px;
+      }
+    </style>
+    <title>Benchmarks</title>
+  </head>
+
+  <body>
+    <header id="header">
+      <div class="header-item">
+        <strong class="header-label">Last Update:</strong>
+        <span id="last-update"></span>
+      </div>
+      <div class="header-item">
+        <strong class="header-label">Repository:</strong>
+        <a id="repository-link" rel="noopener"></a>
+      </div>
+    </header>
+    <main id="main"></main>
+    <footer>
+      <button id="dl-button">Download data as JSON</button>
+      <div class="spacer"></div>
+      <div class="small">Powered by <a rel="noopener" href="https://github.com/marketplace/actions/continuous-benchmark">github-action-benchmark</a></div>
+    </footer>
+
+    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/Chart.min.js"></script>
+    <script src="data.js"></script>
+    <script id="main-script">
+      'use strict';
+      (function() {
+        // Colors from https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+        const toolColors = {
+          cargo: '#dea584',
+          go: '#00add8',
+          benchmarkjs: '#f1e05a',
+          benchmarkluau: '#000080',
+          pytest: '#3572a5',
+          googlecpp: '#f34b7d',
+          catch2: '#f34b7d',
+          julia: '#a270ba',
+          jmh: '#b07219',
+          benchmarkdotnet: '#178600',
+          customBiggerIsBetter: '#38ff38',
+          customSmallerIsBetter: '#ff3838',
+          _: '#333333'
+        };
+
+        function init() {
+          function collectBenchesPerTestCase(entries) {
+            const map = new Map();
+            for (const entry of entries) {
+              const {commit, date, tool, benches} = entry;
+              for (const bench of benches) {
+                const result = { commit, date, tool, bench };
+                const arr = map.get(bench.name);
+                if (arr === undefined) {
+                  map.set(bench.name, [result]);
+                } else {
+                  arr.push(result);
+                }
+              }
+            }
+            return map;
+          }
+
+          const data = window.BENCHMARK_DATA;
+
+          // Render header
+          document.getElementById('last-update').textContent = new Date(data.lastUpdate).toString();
+          const repoLink = document.getElementById('repository-link');
+          repoLink.href = data.repoUrl;
+          repoLink.textContent = data.repoUrl;
+
+          // Render footer
+          document.getElementById('dl-button').onclick = () => {
+            const dataUrl = 'data:,' + JSON.stringify(data, null, 2);
+            const a = document.createElement('a');
+            a.href = dataUrl;
+            a.download = 'benchmark_data.json';
+            a.click();
+          };
+
+          // Prepare data points for charts
+          return Object.keys(data.entries).map(name => ({
+            name,
+            dataSet: collectBenchesPerTestCase(data.entries[name]),
+          }));
+        }
+
+        function renderAllChars(dataSets) {
+
+          function renderGraph(parent, name, dataset) {
+            const canvas = document.createElement('canvas');
+            canvas.className = 'benchmark-chart';
+            parent.appendChild(canvas);
+
+            const color = toolColors[dataset.length > 0 ? dataset[0].tool : '_'];
+            const data = {
+              labels: dataset.map(d => d.commit.id.slice(0, 7)),
+              datasets: [
+                {
+                  label: name,
+                  data: dataset.map(d => d.bench.value),
+                  borderColor: color,
+                  backgroundColor: color + '60', // Add alpha for #rrggbbaa
+                }
+              ],
+            };
+            const options = {
+              scales: {
+                xAxes: [
+                  {
+                    scaleLabel: {
+                      display: true,
+                      labelString: 'commit',
+                    },
+                  }
+                ],
+                yAxes: [
+                  {
+                    scaleLabel: {
+                      display: true,
+                      labelString: dataset.length > 0 ? dataset[0].bench.unit : '',
+                    },
+                    ticks: {
+                      beginAtZero: true,
+                    }
+                  }
+                ],
+              },
+              tooltips: {
+                callbacks: {
+                  afterTitle: items => {
+                    const {index} = items[0];
+                    const data = dataset[index];
+                    return '\n' + data.commit.message + '\n\n' + data.commit.timestamp + ' committed by @' + data.commit.committer.username + '\n';
+                  },
+                  label: item => {
+                    let label = item.value;
+                    const { range, unit } = dataset[item.index].bench;
+                    label += ' ' + unit;
+                    if (range) {
+                      label += ' (' + range + ')';
+                    }
+                    return label;
+                  },
+                  afterLabel: item => {
+                    const { extra } = dataset[item.index].bench;
+                    return extra ? '\n' + extra : '';
+                  }
+                }
+              },
+              onClick: (_mouseEvent, activeElems) => {
+                if (activeElems.length === 0) {
+                  return;
+                }
+                // XXX: Undocumented. How can we know the index?
+                const index = activeElems[0]._index;
+                const url = dataset[index].commit.url;
+                window.open(url, '_blank');
+              },
+            };
+
+            new Chart(canvas, {
+              type: 'line',
+              data,
+              options,
+            });
+          }
+
+          function renderBenchSet(name, benchSet, main) {
+            const setElem = document.createElement('div');
+            setElem.className = 'benchmark-set';
+            main.appendChild(setElem);
+
+            const nameElem = document.createElement('h1');
+            nameElem.className = 'benchmark-title';
+            nameElem.textContent = name;
+            setElem.appendChild(nameElem);
+
+            const graphsElem = document.createElement('div');
+            graphsElem.className = 'benchmark-graphs';
+            setElem.appendChild(graphsElem);
+
+            for (const [benchName, benches] of benchSet.entries()) {
+              renderGraph(graphsElem, benchName, benches)
+            }
+          }
+
+          const main = document.getElementById('main');
+          for (const {name, dataSet} of dataSets) {
+            renderBenchSet(name, dataSet, main);
+          }
+        }
+
+        renderAllChars(init()); // Start
+      })();
+    </script>
+  </body>
+</html>

events.go

@@ -1,58 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"time"
-
-	"github.com/jackc/pgx/v5"
-)
-
-func enableHasuraEventCleaner() {
-	if cfg.HasuraEventCleaner.Enable {
-		if cfg.HasuraEventCleaner.EventMetadataDb == "" {
-			cfg.Logger.Warning("Event metadata db URL not specified, event cleaner not active", nil)
-			return
-		}
-
-		ticker := time.NewTicker(1 * time.Hour)
-		defer ticker.Stop()
-		cfg.Logger.Info("Event cleaner enabled", map[string]interface{}{"interval_in_days": cfg.HasuraEventCleaner.ClearOlderThan})
-
-		time.Sleep(60 * time.Second) // wait for everything to start and settle down
-		cfg.Logger.Info("Initial cleanup of old events", nil)
-		cleanEvents()
-
-		for {
-			select {
-			case <-ticker.C:
-				cfg.Logger.Info("Cleaning up old events", nil)
-				cleanEvents()
-			}
-		}
-	}
-}
-
-func cleanEvents() {
-	conn, err := pgx.Connect(context.Background(), cfg.HasuraEventCleaner.EventMetadataDb)
-	if err != nil {
-		cfg.Logger.Error("Failed to connect to event metadata db", map[string]interface{}{"error": err})
-		return
-	}
-	defer conn.Close(context.Background())
-
-	delQueries := []string{
-		fmt.Sprintf("DELETE FROM hdb_catalog.event_invocation_logs WHERE created_at < now() - interval '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.event_log WHERE created_at < now() - interval '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.hdb_action_log WHERE created_at < NOW() - INTERVAL '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.hdb_cron_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-		fmt.Sprintf("DELETE FROM hdb_catalog.hdb_scheduled_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';", cfg.HasuraEventCleaner.ClearOlderThan),
-	}
-
-	for _, query := range delQueries {
-		_, err := conn.Exec(context.Background(), query)
-		if err != nil {
-			cfg.Logger.Debug("Failed to execute query", map[string]interface{}{"query": query, "error": err})
-		}
-	}
-}

go.mod

@@ -1,53 +0,0 @@
-module github.com/lukaszraczylo/graphql-monitoring-proxy
-
-go 1.21
-
-require (
-	github.com/VictoriaMetrics/metrics v1.33.1
-	github.com/avast/retry-go/v4 v4.6.0
-	github.com/goccy/go-json v0.10.3
-	github.com/gofiber/fiber/v2 v2.52.4
-	github.com/gofrs/flock v0.8.1
-	github.com/google/uuid v1.6.0
-	github.com/gookit/goutil v0.6.15
-	github.com/graphql-go/graphql v0.8.1
-	github.com/jackc/pgx/v5 v5.6.0
-	github.com/lukaszraczylo/ask v0.0.0-20230927103145-2ff1123b4415
-	github.com/lukaszraczylo/go-ratecounter v0.1.8
-	github.com/lukaszraczylo/go-simple-graphql v1.2.14
-	github.com/redis/go-redis/v9 v9.5.3
-	github.com/rs/zerolog v1.33.0
-	github.com/stretchr/testify v1.9.0
-	github.com/valyala/fasthttp v1.54.0
-)
-
-require (
-	github.com/andybalholm/brotli v1.1.0 // indirect
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/gookit/color v1.5.4 // indirect
-	github.com/jackc/pgpassfile v1.0.0 // indirect
-	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
-	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/kr/pretty v0.3.1 // indirect
-	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
-	github.com/rogpeppe/go-internal v1.11.0 // indirect
-	github.com/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
-	golang.org/x/crypto v0.24.0 // indirect
-	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
-	golang.org/x/net v0.26.0 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/sys v0.21.0 // indirect
-	golang.org/x/term v0.21.0 // indirect
-	golang.org/x/text v0.16.0 // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)

go.sum

@@ -1,117 +0,0 @@
-github.com/VictoriaMetrics/metrics v1.33.1 h1:CNV3tfm2Kpv7Y9W3ohmvqgFWPR55tV2c7M2U6OIo+UM=
-github.com/VictoriaMetrics/metrics v1.33.1/go.mod h1:r7hveu6xMdUACXvB8TYdAj8WEsKzWB0EkpJN+RDtOf8=
-github.com/andybalholm/brotli v1.1.0 h1:eLKJA0d02Lf0mVpIDgYnqXcUn0GqVmEFny3VuID1U3M=
-github.com/andybalholm/brotli v1.1.0/go.mod h1:sms7XGricyQI9K10gOSf56VKKWS4oLer58Q+mhRPtnY=
-github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA=
-github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE=
-github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
-github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
-github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
-github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
-github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/goccy/go-json v0.10.3 h1:KZ5WoDbxAIgm2HNbYckL0se1fHD6rz5j4ywS6ebzDqA=
-github.com/goccy/go-json v0.10.3/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
-github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/gofiber/fiber/v2 v2.52.4 h1:P+T+4iK7VaqUsq2PALYEfBBo6bJZ4q3FP8cZ84EggTM=
-github.com/gofiber/fiber/v2 v2.52.4/go.mod h1:KEOE+cXMhXG0zHc9d8+E38hoX+ZN7bhOtgeF2oT6jrQ=
-github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
-github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
-github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
-github.com/gookit/goutil v0.6.15 h1:mMQ0ElojNZoyPD0eVROk5QXJPh2uKR4g06slgPDF5Jo=
-github.com/gookit/goutil v0.6.15/go.mod h1:qdKdYEHQdEtyH+4fNdQNZfJHhI0jUZzHxQVAV3DaMDY=
-github.com/graphql-go/graphql v0.8.1 h1:p7/Ou/WpmulocJeEx7wjQy611rtXGQaAcXGqanuMMgc=
-github.com/graphql-go/graphql v0.8.1/go.mod h1:nKiHzRM0qopJEwCITUuIsxk9PlVlwIiiI8pnJEhordQ=
-github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
-github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
-github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
-github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.6.0 h1:SWJzexBzPL5jb0GEsrPMLIsi/3jOo7RHlzTjcAeDrPY=
-github.com/jackc/pgx/v5 v5.6.0/go.mod h1:DNZ/vlrUnhWCoFGxHAG8U2ljioxukquj7utPDgtQdTw=
-github.com/jackc/puddle/v2 v2.2.1 h1:RhxXJtFG022u4ibrCSMSiu5aOq1i77R3OHKNJj77OAk=
-github.com/jackc/puddle/v2 v2.2.1/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
-github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
-github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
-github.com/lukaszraczylo/ask v0.0.0-20230927103145-2ff1123b4415 h1:lvI8Wlbg4PxkRcg2f10wgoaRpfN19v+YdRek3+dLtlM=
-github.com/lukaszraczylo/ask v0.0.0-20230927103145-2ff1123b4415/go.mod h1:M+UVdyqZs++xtEPrascaVmZdOMhCnxjZ2SgH+xHpR0c=
-github.com/lukaszraczylo/go-ratecounter v0.1.8 h1:ZYm6Wkn58ZAlFWRmC7PaD4oAYHWcu8/0MUDWGe3PnJQ=
-github.com/lukaszraczylo/go-ratecounter v0.1.8/go.mod h1:TqXEOCtFJStk1i0tkipprv1kiDHGon1MVUisjSTBSKM=
-github.com/lukaszraczylo/go-simple-graphql v1.2.14 h1:Dth+yZ+1ialCpnslSb6UgHbXszExjDUu/I95QZbnWVU=
-github.com/lukaszraczylo/go-simple-graphql v1.2.14/go.mod h1:pSKmm9OLGoS9pjmIvhBB/fo0+LganRrL29CN3fdkRPw=
-github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
-github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
-github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
-github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
-github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.5.3 h1:fOAp1/uJG+ZtcITgZOfYFmTKPE7n4Vclj1wZFgRciUU=
-github.com/redis/go-redis/v9 v9.5.3/go.mod h1:hdY0cQFCN4fnSYT6TkisLufl/4W5UIXyv0b/CLO2V2M=
-github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
-github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M=
-github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA=
-github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg=
-github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8=
-github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
-github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
-github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
-github.com/valyala/fasthttp v1.54.0 h1:cCL+ZZR3z3HPLMVfEYVUMtJqVaui0+gu7Lx63unHwS0=
-github.com/valyala/fasthttp v1.54.0/go.mod h1:6dt4/8olwq9QARP/TDuPmWyWcl4byhpvTJ4AAtcz+QM=
-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=
-golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI=
-golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
-golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
-golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ=
-golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
-golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA=
-golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0=
-golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
-golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
-gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

graphql.go

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

graphql_test.go

@@ -1,320 +0,0 @@
-package main
-
-import (
-	"github.com/valyala/fasthttp"
-)
-
-func (suite *Tests) Test_parseGraphQLQuery() {
-
-	type results struct {
-		op_name      string
-		op_type      string
-		cached_ttl   int
-		returnCode   int
-		is_cached    bool
-		shouldBlock  bool
-		shouldIgnore bool
-	}
-
-	type queries struct {
-		headers map[string]string
-		body    string
-	}
-
-	tests := []struct {
-		name             string
-		suppliedSettings *config
-		suppliedQuery    queries
-		wantResults      results
-	}{
-		{
-			name: "test empty body",
-			suppliedQuery: queries{
-				body:    "",
-				headers: map[string]string{},
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: true,
-				op_name:      "",
-				op_type:      "",
-			},
-		},
-
-		{
-			name: "test empty json",
-			suppliedQuery: queries{
-				body:    "{}",
-				headers: map[string]string{},
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: true,
-				op_name:      "",
-				op_type:      "",
-			},
-		},
-
-		{
-			name: "test empty with some random garbage",
-			suppliedQuery: queries{
-				body:    "{\"variables\": {\"id\": \"1\"}}",
-				headers: map[string]string{},
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: true,
-				op_name:      "",
-				op_type:      "",
-			},
-		},
-
-		{
-			name: "test valid query with op name",
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyQuery { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyQuery",
-				op_type:      "query",
-			},
-		},
-
-		{
-			name: "test valid query with op name, variables and cache",
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyQuery @cached { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\", \"variables\": {\"id\": \"1\"}}",
-			},
-			wantResults: results{
-				is_cached:    true,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyQuery",
-				op_type:      "query",
-			},
-		},
-
-		{
-			name: "test valid query with op name, cache and ttl",
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyQuery @cached(ttl: 60) { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\", \"variables\": {\"id\": \"1\"}}",
-			},
-			wantResults: results{
-				is_cached:    true,
-				cached_ttl:   60,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyQuery",
-				op_type:      "query",
-			},
-		},
-
-		{
-			name: "test valid query with op name, force refreshed cache",
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyQuery @cached(refresh: true) { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\", \"variables\": {\"id\": \"1\"}}",
-			},
-			wantResults: results{
-				is_cached:    true,
-				cached_ttl:   0,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyQuery",
-				op_type:      "query",
-			},
-		},
-
-		{
-			name: "test valid query with op name, cache and INVALID ttl",
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyQuery @cached(ttl: nope) { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\", \"variables\": {\"id\": \"1\"}}",
-			},
-			wantResults: results{
-				is_cached:    true,
-				cached_ttl:   0,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyQuery",
-				op_type:      "query",
-			},
-		},
-
-		{
-			name: "test mutation query with op name",
-			suppliedQuery: queries{
-				body: "{\"query\":\"mutation MyMutation { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyMutation",
-				op_type:      "mutation",
-			},
-		},
-
-		{
-			name: "test mutation query with config: read only",
-			suppliedSettings: func() *config {
-				parseConfig()
-				cfg.Server.ReadOnlyMode = true
-				return cfg
-			}(),
-			suppliedQuery: queries{
-				body: "{\"query\":\"mutation MyMutation { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } }\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  true,
-				shouldIgnore: false,
-				op_name:      "MyMutation",
-				op_type:      "mutation",
-				returnCode:   403,
-			},
-		},
-
-		{
-			name: "test simple query with introspection __schema",
-			suppliedQuery: queries{
-				body: "{\"query\":\"mutation MyMutation { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __schema } }\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "MyMutation",
-				op_type:      "mutation",
-			},
-		},
-
-		{
-			name: "test simple query with introspection __schema config: block introspection",
-			suppliedSettings: func() *config {
-				parseConfig()
-				cfg.Security.BlockIntrospection = true
-				return cfg
-			}(),
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyIntroQuery { tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __schema } }\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  true,
-				shouldIgnore: false,
-				op_name:      "MyIntroQuery",
-				op_type:      "query",
-				returnCode:   403,
-			},
-		},
-
-		{
-			name: "test user supplied query with introspection #1 - config: block",
-			suppliedSettings: func() *config {
-				parseConfig()
-				cfg.Security.BlockIntrospection = true
-				cfg.Security.IntrospectionAllowed = []string{}
-				return cfg
-			}(),
-			suppliedQuery: queries{
-				body: "{\"query\":\"{__schema {queryType {fields {name description}}}}\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  true,
-				shouldIgnore: false,
-				op_name:      "undefined",
-				op_type:      "query",
-				returnCode:   403,
-			},
-		},
-
-		{
-			name: "test user supplied query with introspection #1 - config: block & allow __schema",
-			suppliedSettings: func() *config {
-				parseConfig()
-				cfg.Security.BlockIntrospection = true
-				cfg.Security.IntrospectionAllowed = []string{"__schema"}
-				return cfg
-			}(),
-			suppliedQuery: queries{
-				body: "{\"query\":\"{__schema {queryType {fields {name description}}}}\"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: false,
-				op_name:      "undefined",
-				op_type:      "query",
-				returnCode:   200,
-			},
-		},
-
-		{
-			name: "test invalid query",
-			suppliedQuery: queries{
-				body: "{\"query\":\"query MyQuery tg_users(where: {handle: {_eq: \\\"tozuo\\\"}}) { id __typename } \"}",
-			},
-			wantResults: results{
-				is_cached:    false,
-				shouldBlock:  false,
-				shouldIgnore: true,
-				op_name:      "",
-				op_type:      "",
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			cfg = &config{}
-			parseConfig()
-			ctx_headers := func() *fasthttp.RequestHeader {
-				h := fasthttp.RequestHeader{}
-				for k, v := range tt.suppliedQuery.headers {
-					h.Add(k, v)
-				}
-				return &h
-			}()
-
-			ctx_request := fasthttp.Request{
-				Header: *ctx_headers,
-			}
-
-			ctx_request.AppendBody([]byte(tt.suppliedQuery.body))
-
-			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{
-				Request: ctx_request,
-			})
-
-			// defer func() {
-			// 	cfg = &config{}
-			// 	parseConfig()
-			// 	suite.app.ReleaseCtx(ctx)
-			// }()
-
-			assert.NotNil(ctx, "Fiber context is nil")
-
-			if tt.suppliedSettings != nil {
-				cfg = tt.suppliedSettings
-			}
-			prepareQueriesAndExemptions()
-			parseResult := parseGraphQLQuery(ctx)
-			assert.Equal(tt.wantResults.op_type, parseResult.operationType, "Unexpected operation type "+tt.name)
-			assert.Equal(tt.wantResults.op_name, parseResult.operationName, "Unexpected operation name "+tt.name)
-			assert.Equal(tt.wantResults.is_cached, parseResult.cacheRequest, "Unexpected cache value "+tt.name)
-			assert.Equal(tt.wantResults.cached_ttl, parseResult.cacheTime, "Unexpected cache TTL value "+tt.name)
-			assert.Equal(tt.wantResults.shouldBlock, parseResult.shouldBlock, "Unexpected block value "+tt.name)
-			assert.Equal(tt.wantResults.shouldIgnore, parseResult.shouldIgnore, "Unexpected ignore value "+tt.name)
-
-			if tt.wantResults.returnCode > 0 {
-				assert.Equal(tt.wantResults.returnCode, ctx.Response().StatusCode(), "Unexpected return code", tt.name)
-			}
-		})
-	}
-}

logging/logging.go

@@ -1,123 +0,0 @@
-package libpack_logging
-
-import (
-	"io"
-	"os"
-	"sync"
-	"time"
-
-	"github.com/gookit/goutil/envutil"
-	"github.com/rs/zerolog"
-)
-
-type LogConfig struct {
-	logger zerolog.Logger
-}
-
-var (
-	baseLogger zerolog.Logger
-
-	eventPool = sync.Pool{
-		New: func() interface{} {
-			return new(zerolog.Event)
-		},
-	}
-
-	fieldMapPool = sync.Pool{
-		New: func() interface{} {
-			return make(map[string]interface{})
-		},
-	}
-)
-
-func init() {
-	zerolog.TimeFieldFormat = time.RFC3339
-	zerolog.MessageFieldName = "short_message"
-	zerolog.TimestampFieldName = "timestamp"
-	zerolog.LevelFieldName = "level"
-	zerolog.LevelFatalValue = "critical"
-
-	baseLogger = zerolog.New(os.Stdout).With().Timestamp().Logger()
-
-	switch logLevel := envutil.Getenv("LOG_LEVEL", "info"); logLevel {
-	case "debug":
-		baseLogger = baseLogger.Level(zerolog.DebugLevel)
-	case "warn":
-		baseLogger = baseLogger.Level(zerolog.WarnLevel)
-	case "error":
-		baseLogger = baseLogger.Level(zerolog.ErrorLevel)
-	default:
-		baseLogger = baseLogger.Level(zerolog.InfoLevel)
-	}
-}
-
-func NewLogger() *LogConfig {
-	return &LogConfig{logger: baseLogger}
-}
-
-func (lw *LogConfig) log(w io.Writer, level zerolog.Level, message string, fields map[string]interface{}) {
-	logger := lw.logger.Output(w)
-	event := logger.WithLevel(level).CallerSkipFrame(3)
-
-	for k, val := range fields {
-		switch v := val.(type) {
-		case string:
-			event = event.Str(k, v)
-		case int:
-			event = event.Int(k, v)
-		case float64:
-			event = event.Float64(k, v)
-		default:
-			event = event.Interface(k, val)
-		}
-	}
-
-	event.Msg(message)
-}
-
-func (lw *LogConfig) logWithLevel(level zerolog.Level, message string, fields map[string]interface{}) {
-	if lw.logger.GetLevel() > level {
-		return
-	}
-	if lw.logger.GetLevel() <= level {
-		w := os.Stdout
-		if level >= zerolog.ErrorLevel {
-			w = os.Stderr
-		}
-		lw.log(w, level, message, fields)
-	}
-}
-
-func (lw *LogConfig) Debug(message string, fields map[string]interface{}) {
-	lw.logWithLevel(zerolog.DebugLevel, message, fields)
-}
-
-func (lw *LogConfig) Info(message string, fields map[string]interface{}) {
-	lw.logWithLevel(zerolog.InfoLevel, message, fields)
-}
-
-func (lw *LogConfig) Warning(message string, fields map[string]interface{}) {
-	lw.logWithLevel(zerolog.WarnLevel, message, fields)
-}
-
-func (lw *LogConfig) Error(message string, fields map[string]interface{}) {
-	lw.logWithLevel(zerolog.ErrorLevel, message, fields)
-}
-
-func (lw *LogConfig) Critical(message string, fields map[string]interface{}) {
-	lw.logWithLevel(zerolog.FatalLevel, message, fields)
-	os.Exit(1)
-}
-
-// Helper function to get a new fields map from the pool
-func getFieldsMap() map[string]interface{} {
-	return fieldMapPool.Get().(map[string]interface{})
-}
-
-// Helper function to put a used fields map back into the pool
-func putFieldsMap(fields map[string]interface{}) {
-	for k := range fields {
-		delete(fields, k)
-	}
-	fieldMapPool.Put(fields)
-}

logging/logging_bench_test.go

@@ -1,32 +0,0 @@
-package libpack_logging
-
-import (
-	"os"
-	"testing"
-)
-
-func BenchmarkNewLogger(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		NewLogger()
-	}
-}
-
-func BenchmarkInfoLog(b *testing.B) {
-	oldEnv := os.Getenv("LOG_LEVEL")
-	os.Setenv("LOG_LEVEL", "info")
-	oldStdout := os.Stdout
-	oldStderr := os.Stderr
-	os.Stdout, _ = os.Open(os.DevNull)
-	os.Stderr, _ = os.Open(os.DevNull)
-	defer func() {
-		os.Stdout = oldStdout
-		os.Stderr = oldStderr
-		os.Setenv("LOG_LEVEL", oldEnv)
-	}()
-
-	testsLogger := NewLogger()
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		testsLogger.Info("test", map[string]interface{}{"test": "test"})
-	}
-}

main.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"flag"
-	"os"
-	"strings"
-	"sync"
-
-	"github.com/gofiber/fiber/v2/middleware/proxy"
-	"github.com/gookit/goutil/envutil"
-	graphql "github.com/lukaszraczylo/go-simple-graphql"
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-var cfg *config
-var once sync.Once
-
-// function get value from the env where the value can be anything
-func getDetailsFromEnv[T any](key string, defaultValue T) T {
-	var result any
-	if _, ok := os.LookupEnv("GMP_" + key); ok {
-		key = "GMP_" + key
-	}
-	switch v := any(defaultValue).(type) {
-	case string:
-		result = envutil.Getenv(key, v)
-	case int:
-		result = envutil.GetInt(key, v)
-	case bool:
-		result = envutil.GetBool(key, v)
-	default:
-		result = defaultValue
-	}
-	return result.(T)
-}
-
-func parseConfig() {
-	libpack_config.PKG_NAME = "graphql_proxy"
-	c := config{}
-	c.Server.PortGraphQL = getDetailsFromEnv("PORT_GRAPHQL", 8080)
-	c.Server.PortMonitoring = getDetailsFromEnv("MONITORING_PORT", 9393)
-	c.Server.HostGraphQL = getDetailsFromEnv("HOST_GRAPHQL", "http://localhost/")
-	c.Server.HostGraphQLReadOnly = getDetailsFromEnv("HOST_GRAPHQL_READONLY", "")
-	c.Client.JWTUserClaimPath = getDetailsFromEnv("JWT_USER_CLAIM_PATH", "")
-	c.Client.JWTRoleClaimPath = getDetailsFromEnv("JWT_ROLE_CLAIM_PATH", "")
-	c.Client.RoleFromHeader = getDetailsFromEnv("ROLE_FROM_HEADER", "")
-	c.Client.RoleRateLimit = getDetailsFromEnv("ROLE_RATE_LIMIT", false)
-	/* in-memory cache */
-	c.Cache.CacheEnable = getDetailsFromEnv("ENABLE_GLOBAL_CACHE", false)
-	c.Cache.CacheTTL = getDetailsFromEnv("CACHE_TTL", 60)
-	/* redis cache */
-	c.Cache.CacheRedisEnable = getDetailsFromEnv("ENABLE_REDIS_CACHE", false)
-	c.Cache.CacheRedisURL = getDetailsFromEnv("CACHE_REDIS_URL", "localhost:6379")
-	c.Cache.CacheRedisPassword = getDetailsFromEnv("CACHE_REDIS_PASSWORD", "")
-	c.Cache.CacheRedisDB = getDetailsFromEnv("CACHE_REDIS_DB", 0)
-	c.Security.BlockIntrospection = getDetailsFromEnv("BLOCK_SCHEMA_INTROSPECTION", false)
-	c.Security.IntrospectionAllowed = func() []string {
-		urls := getDetailsFromEnv("ALLOWED_INTROSPECTION", "")
-		if urls == "" {
-			return nil
-		}
-		return strings.Split(urls, ",")
-	}()
-	c.Logger = libpack_logging.NewLogger()
-	c.Server.HealthcheckGraphQL = getDetailsFromEnv("HEALTHCHECK_GRAPHQL_URL", "")
-	c.Client.GQLClient = graphql.NewConnection()
-	c.Client.GQLClient.SetEndpoint(c.Server.HealthcheckGraphQL)
-	c.Server.AccessLog = getDetailsFromEnv("ENABLE_ACCESS_LOG", false)
-	c.Server.ReadOnlyMode = getDetailsFromEnv("READ_ONLY_MODE", false)
-	c.Server.AllowURLs = func() []string {
-		urls := getDetailsFromEnv("ALLOWED_URLS", "")
-		if urls == "" {
-			return nil
-		}
-		return strings.Split(urls, ",")
-	}()
-	c.Client.ClientTimeout = getDetailsFromEnv("PROXIED_CLIENT_TIMEOUT", 120)
-	c.Client.FastProxyClient = createFasthttpClient(c.Client.ClientTimeout)
-	proxy.WithClient(c.Client.FastProxyClient) // setting the global proxy client here instead of per request
-	c.Server.EnableApi = getDetailsFromEnv("ENABLE_API", false)
-	c.Server.ApiPort = getDetailsFromEnv("API_PORT", 9090)
-	c.Api.BannedUsersFile = getDetailsFromEnv("BANNED_USERS_FILE", "/go/src/app/banned_users.json")
-	c.Server.PurgeOnCrawl = getDetailsFromEnv("PURGE_METRICS_ON_CRAWL", false)
-	c.Server.PurgeEvery = getDetailsFromEnv("PURGE_METRICS_ON_TIMER", 0)
-	c.HasuraEventCleaner.Enable = getDetailsFromEnv("HASURA_EVENT_CLEANER", false)
-	c.HasuraEventCleaner.ClearOlderThan = getDetailsFromEnv("HASURA_EVENT_CLEANER_OLDER_THAN", 1)
-	c.HasuraEventCleaner.EventMetadataDb = getDetailsFromEnv("HASURA_EVENT_METADATA_DB", "")
-	cfg = &c
-
-	enableCache() // takes close to no resources, but can be used with dynamic query cache
-	loadRatelimitConfig()
-	once.Do(func() {
-		go enableApi()
-		go enableHasuraEventCleaner()
-	})
-	prepareQueriesAndExemptions()
-}
-
-func main() {
-	parseConfig()
-	StartMonitoringServer()
-	StartHTTPProxy()
-}
-
-func ifNotInTest() bool {
-	return flag.Lookup("test.v") == nil
-}

main_test.go

@@ -1,115 +0,0 @@
-package main
-
-import (
-	"os"
-	"testing"
-	"time"
-
-	"github.com/goccy/go-json"
-	"github.com/gofiber/fiber/v2"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	assertions "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type Tests struct {
-	suite.Suite
-	app *fiber.App
-}
-
-var (
-	assert *assertions.Assertions
-)
-
-func (suite *Tests) BeforeTest(suiteName, testName string) {
-}
-
-func (suite *Tests) SetupTest() {
-	assert = assertions.New(suite.T())
-	suite.app = fiber.New(
-		fiber.Config{
-			DisableStartupMessage: true,
-			JSONEncoder:           json.Marshal,
-			JSONDecoder:           json.Unmarshal,
-		},
-	)
-	cacheStats = &CacheStats{}
-
-	// Initialize a simple in-memory cache client for testing purposes
-	cfg.Cache.Client = libpack_cache.New(5 * time.Minute)
-	parseConfig()
-	enableApi()
-	StartMonitoringServer()
-	cfg.Logger = libpack_logging.NewLogger()
-	// Setup environment variables here if needed
-	os.Setenv("GMP_TEST_STRING", "testValue")
-	os.Setenv("GMP_TEST_INT", "123")
-	os.Setenv("GMP_TEST_BOOL", "true")
-	os.Setenv("NON_GMP_TEST_INT", "31337")
-}
-
-// TearDownTest is run after each test to clean up
-func (suite *Tests) TearDownTest() {
-	// Clean up environment variables here if needed
-	os.Unsetenv("GMP_TEST_STRING")
-	os.Unsetenv("GMP_TEST_INT")
-	os.Unsetenv("GMP_TEST_BOOL")
-	os.Unsetenv("NON_GMP_TEST_INT")
-}
-
-// func (suite *Tests) AfterTest(suiteName, testName string) {)
-
-func TestSuite(t *testing.T) {
-	cfg = &config{}
-	parseConfig()
-	StartMonitoringServer()
-	suite.Run(t, new(Tests))
-}
-
-func (suite *Tests) Test_envVariableSetting() {
-	tests := []struct {
-		defaultValue any
-		expected     any
-		name         string
-		envKey       string
-	}{
-		{
-			name:         "test_string",
-			envKey:       "TEST_STRING",
-			defaultValue: "default",
-			expected:     "testValue",
-		},
-		{
-			name:         "test_int",
-			envKey:       "TEST_INT",
-			defaultValue: 0,
-			expected:     123,
-		},
-		{
-			name:         "test_bool",
-			envKey:       "TEST_BOOL",
-			defaultValue: false,
-			expected:     true,
-		},
-		{
-			name:         "test_non_prefixed",
-			envKey:       "NON_GMP_TEST_INT",
-			defaultValue: 0,
-			expected:     31337,
-		},
-		{
-			name:         "test_non_existing",
-			envKey:       "NON_EXISTING",
-			defaultValue: "default_val",
-			expected:     "default_val",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result := getDetailsFromEnv(tt.envKey, tt.defaultValue)
-			assert.Equal(tt.expected, result)
-		})
-	}
-}

monitoring.go

@@ -1,11 +0,0 @@
-package main
-
-import (
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-)
-
-func StartMonitoringServer() {
-	cfg.Monitoring = libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{PurgeOnCrawl: cfg.Server.PurgeOnCrawl, PurgeEvery: cfg.Server.PurgeEvery})
-	cfg.Monitoring.AddMetricsPrefix("graphql_proxy")
-	cfg.Monitoring.RegisterDefaultMetrics()
-}

monitoring/defaults.go

@@ -1,15 +0,0 @@
-package libpack_monitoring
-
-func (ms *MetricsSetup) RegisterDefaultMetrics() {
-	ms.RegisterMetricsCounter(MetricsSucceeded, nil)
-	ms.RegisterMetricsCounter(MetricsFailed, nil)
-	ms.RegisterMetricsCounter(MetricsSkipped, nil)
-	ms.RegisterMetricsHistogram(MetricsDuration, nil)
-	ms.RegisterMetricsCounter(MetricsCacheHit, nil)
-	ms.RegisterMetricsCounter(MetricsCacheMiss, nil)
-	ms.RegisterMetricsCounter(MetricsQueriesCached, nil)
-}
-
-func (ms *MetricsSetup) RegisterGoMetrics() {
-	// TODO: metrics.WriteProcessMetrics(ms.metrics_set)
-}

monitoring/helpers.go

@@ -1,129 +0,0 @@
-package libpack_monitoring
-
-import (
-	"fmt"
-	"os"
-	"sort"
-	"strings"
-	"unicode"
-
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-)
-
-func (ms *MetricsSetup) get_metrics_name(name string, labels map[string]string) (complete_name string) {
-	const unknownPodName = "unknown"
-	var sb strings.Builder
-
-	// Prepare default labels without initializing a new map
-	podName := unknownPodName
-	if hn, err := os.Hostname(); err == nil {
-		podName = hn
-	}
-	if labels == nil {
-		labels = map[string]string{
-			"microservice": libpack_config.PKG_NAME,
-			"pod":          podName,
-		}
-	} else {
-		if _, exists := labels["microservice"]; !exists {
-			labels["microservice"] = libpack_config.PKG_NAME
-		}
-		if _, exists := labels["pod"]; !exists {
-			labels["pod"] = podName
-		}
-	}
-
-	// Prefix handling
-	if ms.metrics_prefix != "" {
-		sb.WriteString(ms.metrics_prefix)
-		sb.WriteString("_")
-	}
-	sb.WriteString(name)
-
-	// Append labels if any
-	if len(labels) > 0 {
-		sb.WriteString("{")
-
-		keys := make([]string, 0, len(labels))
-		for k := range labels {
-			keys = append(keys, k)
-		}
-		sort.Strings(keys)
-
-		for i, k := range keys {
-			if i > 0 {
-				sb.WriteString(",")
-			}
-			sb.WriteString(k)
-			sb.WriteString("=\"")
-			sb.WriteString(labels[k])
-			sb.WriteString("\"")
-		}
-		sb.WriteString("}")
-	}
-
-	return sb.String()
-}
-
-// validate_metrics_name validates the name of the metric to adhere to the Prometheus naming conventions
-// https://prometheus.io/docs/practices/naming/
-func validate_metrics_name(name string) error {
-	var sb strings.Builder // Use strings.Builder for efficient string concatenation
-
-	// Track if the last character was an underscore to avoid duplicate underscores
-	lastWasUnderscore := false
-
-	for _, r := range name {
-		// Convert spaces to underscores and skip non-alphanumeric characters except underscores
-		if r == ' ' || (unicode.IsLetter(r) || unicode.IsDigit(r) || r == '_') {
-			if r == ' ' || r == '_' {
-				if lastWasUnderscore {
-					continue // Skip if the previous character was also an underscore
-				}
-				r = '_' // Convert spaces to underscores
-				lastWasUnderscore = true
-			} else {
-				lastWasUnderscore = false
-			}
-			sb.WriteRune(r) // Add valid characters to the builder
-		}
-	}
-	// Trim leading and trailing underscores
-	name_new := strings.Trim(sb.String(), "_")
-
-	// Check if the processed name matches the original input
-	if name_new != name {
-		return fmt.Errorf("Invalid metric name: %s, expected %s", name, name_new)
-	}
-	return nil
-}
-
-func compile_metrics_with_labels(name string, labels map[string]string) string {
-	var totalLength int
-	totalLength += len(name)
-	for k, v := range labels {
-		totalLength += len(k) + len(v) + 2
-	}
-
-	var sb strings.Builder
-	sb.Grow(totalLength + 1)
-
-	sb.WriteString(name)
-
-	// Collect keys and sort them
-	keys := make([]string, 0, len(labels))
-	for k := range labels {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-
-	// Append sorted key-value pairs to the builder
-	for _, k := range keys {
-		sb.WriteString("_")
-		sb.WriteString(k)
-		sb.WriteString("_")
-		sb.WriteString(labels[k])
-	}
-
-	return sb.String()
-}

monitoring/helpers_bench_test.go

@@ -1,44 +0,0 @@
-package libpack_monitoring
-
-import (
-	"testing"
-
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-)
-
-func BenchmarkGetMetricsName(b *testing.B) {
-	// Setup environment
-	libpack_config.PKG_NAME = "test_service"
-
-	ms := &MetricsSetup{metrics_prefix: "test_prefix"}
-
-	labels := map[string]string{
-		"env":    "production",
-		"region": "us-west-2",
-	}
-
-	// Run the benchmark
-	for n := 0; n < b.N; n++ {
-		ms.get_metrics_name("request_count", labels)
-	}
-}
-
-func BenchmarkCompileMetricsWithLabels(b *testing.B) {
-	labels := map[string]string{
-		"env":    "production",
-		"region": "us-west-2",
-		"app":    "api-server",
-	}
-
-	for n := 0; n < b.N; n++ {
-		compile_metrics_with_labels("request_count", labels)
-	}
-}
-
-func BenchmarkValidateMetricsName(b *testing.B) {
-	input := "valid metric name with special chars @#! and underscores__"
-
-	for n := 0; n < b.N; n++ {
-		validate_metrics_name(input)
-	}
-}

monitoring/helpers_test.go

@@ -1,143 +0,0 @@
-package libpack_monitoring
-
-import (
-	"os"
-	"testing"
-
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestGetMetricsName(t *testing.T) {
-	ms := &MetricsSetup{metrics_prefix: "prefix"}
-	libpack_config.PKG_NAME = "example_microservice"
-
-	tests := []struct {
-		name           string
-		metricName     string
-		labels         map[string]string
-		expectedOutput string
-	}{
-		{
-			name:           "No labels",
-			metricName:     "test_metric",
-			labels:         nil,
-			expectedOutput: "prefix_test_metric{microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:       "With labels",
-			metricName: "test_metric",
-			labels: map[string]string{
-				"label1": "value1",
-				"label2": "value2",
-			},
-			expectedOutput: "prefix_test_metric{label1=\"value1\",label2=\"value2\",microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:       "Alphabetical order labels",
-			metricName: "test_metric",
-			labels: map[string]string{
-				"label2": "value2",
-				"label1": "value1",
-			},
-			expectedOutput: "prefix_test_metric{label1=\"value1\",label2=\"value2\",microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:           "Empty metric name",
-			metricName:     "",
-			labels:         nil,
-			expectedOutput: "prefix_{microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:           "Empty labels map",
-			metricName:     "test_metric",
-			labels:         map[string]string{},
-			expectedOutput: "prefix_test_metric{microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:       "Single label",
-			metricName: "test_metric",
-			labels: map[string]string{
-				"label1": "value1",
-			},
-			expectedOutput: "prefix_test_metric{label1=\"value1\",microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:       "Multiple labels with special characters",
-			metricName: "test_metric",
-			labels: map[string]string{
-				"label-2": "value-2",
-				"label_1": "value_1",
-			},
-			expectedOutput: "prefix_test_metric{label-2=\"value-2\",label_1=\"value_1\",microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-		{
-			name:       "Prefix only",
-			metricName: "",
-			labels: map[string]string{
-				"label1": "value1",
-			},
-			expectedOutput: "prefix_{label1=\"value1\",microservice=\"example_microservice\",pod=\"" + getPodName() + "\"}",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := ms.get_metrics_name(tt.metricName, tt.labels)
-			assert.Equal(t, tt.expectedOutput, result)
-		})
-	}
-}
-
-func TestCompileMetricsWithLabels(t *testing.T) {
-	tests := []struct {
-		name   string
-		labels map[string]string
-		want   string
-	}{
-		{"request_count", map[string]string{"env": "production", "region": "us-west-2"}, "request_count_env_production_region_us-west-2"},
-		{"metric_name", map[string]string{}, "metric_name"},
-		{"metric_name", nil, "metric_name"},
-		{"metric_name", map[string]string{"key1": "value1"}, "metric_name_key1_value1"},
-		{"metric_name", map[string]string{"k": "v", "key2": "value2"}, "metric_name_k_v_key2_value2"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if got := compile_metrics_with_labels(tt.name, tt.labels); got != tt.want {
-				t.Errorf("compile_metrics_with_labels() = %v, want %v", got, tt.want)
-			}
-		})
-	}
-}
-
-func TestValidateMetricsName(t *testing.T) {
-	tests := []struct {
-		name    string
-		input   string
-		wantErr bool
-	}{
-		{"Valid name", "valid_metric_name", false},
-		{"Name with spaces", "valid metric name", true},
-		{"Name with special chars", "valid@metric#name!", true},
-		{"Name with leading underscore", "_valid_metric_name", true},
-		{"Name with trailing underscore", "valid_metric_name_", true},
-		{"Name with consecutive underscores", "valid__metric__name", true},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			if err := validate_metrics_name(tt.input); (err != nil) != tt.wantErr {
-				t.Errorf("validate_metrics_name() error = %v, wantErr %v", err, tt.wantErr)
-			}
-		})
-	}
-}
-
-func getPodName() string {
-	podName, err := os.Hostname()
-	if err != nil {
-		return "unknown"
-	}
-	return podName
-}

monitoring/monitoring.go

@@ -1,163 +0,0 @@
-// Package `libpack_monitoring` provides and easy way to add prometheus metrics to your application.
-// It also provides a way to add custom metrics to the already started prometheus registry.
-
-package libpack_monitoring
-
-import (
-	"flag"
-	"fmt"
-	"time"
-
-	"github.com/VictoriaMetrics/metrics"
-	"github.com/gofiber/fiber/v2"
-	"github.com/gookit/goutil/envutil"
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-	logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-type MetricsSetup struct {
-	metrics_set        *metrics.Set
-	metrics_set_custom *metrics.Set
-	ic                 *InitConfig
-	metrics_prefix     string
-}
-
-var (
-	log *logging.LogConfig
-)
-
-type InitConfig struct {
-	PurgeOnCrawl bool
-	PurgeEvery   int
-}
-
-func NewMonitoring(ic *InitConfig) *MetricsSetup {
-	log = logging.NewLogger()
-	ms := &MetricsSetup{ic: ic}
-	ms.metrics_set = metrics.NewSet()
-	ms.metrics_set_custom = metrics.NewSet()
-	// if not testing, start the prometheus endpoint
-
-	if flag.Lookup("test.v") == nil {
-		go ms.startPrometheusEndpoint()
-
-		if ic.PurgeEvery > 0 {
-			ticker := time.NewTicker(time.Duration(ic.PurgeEvery) * time.Second)
-			go func() {
-				for range ticker.C {
-					ms.PurgeMetrics()
-				}
-			}()
-		}
-	}
-
-	return ms
-}
-
-func (ms *MetricsSetup) startPrometheusEndpoint() {
-	app := fiber.New(fiber.Config{
-		DisableStartupMessage: true,
-		AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
-	})
-	app.Get("/metrics", ms.metricsEndpoint)
-	err := app.Listen(fmt.Sprintf(":%d", envutil.GetInt("MONITORING_PORT", 9393)))
-	if err != nil {
-		fmt.Println("Can't start the service: ", err)
-	}
-}
-
-func (ms *MetricsSetup) metricsEndpoint(c *fiber.Ctx) error {
-	ms.metrics_set.WritePrometheus(c.Response().BodyWriter())
-	ms.metrics_set_custom.WritePrometheus(c.Response().BodyWriter())
-
-	if ms.ic.PurgeOnCrawl && ms.ic.PurgeEvery == 0 {
-		ms.PurgeMetrics()
-	}
-	return nil
-}
-
-func (ms *MetricsSetup) AddMetricsPrefix(prefix string) {
-	ms.metrics_prefix = prefix
-}
-
-func (ms *MetricsSetup) ListActiveMetrics() []string {
-	return ms.metrics_set.ListMetricNames()
-}
-
-func (ms *MetricsSetup) RegisterMetricsGauge(metric_name string, labels map[string]string, val float64) *metrics.Gauge {
-	if validate_metrics_name(metric_name) != nil {
-		log.Critical("RegisterMetricsGauge() error", map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name})
-		return nil
-	}
-	return ms.metrics_set_custom.GetOrCreateGauge(ms.get_metrics_name(metric_name, labels), func() float64 {
-		// get current value of the gauge and add val to it
-		return val
-	})
-}
-
-func (ms *MetricsSetup) RegisterMetricsCounter(metric_name string, labels map[string]string) *metrics.Counter {
-	if validate_metrics_name(metric_name) != nil {
-		log.Critical("RegisterMetricsCounter() error", map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name})
-		return nil
-	}
-	if metric_name == MetricsSucceeded || metric_name == MetricsFailed || metric_name == MetricsSkipped {
-		return ms.metrics_set.GetOrCreateCounter(ms.get_metrics_name(metric_name, labels))
-	}
-	return ms.metrics_set_custom.GetOrCreateCounter(ms.get_metrics_name(metric_name, labels))
-}
-
-func (ms *MetricsSetup) RegisterFloatCounter(metric_name string, labels map[string]string) *metrics.FloatCounter {
-	if validate_metrics_name(metric_name) != nil {
-		log.Critical("RegisterFloatCounter() error", map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name})
-		return nil
-	}
-	return ms.metrics_set_custom.GetOrCreateFloatCounter(ms.get_metrics_name(metric_name, labels))
-}
-
-func (ms *MetricsSetup) RegisterMetricsSummary(metric_name string, labels map[string]string) *metrics.Summary {
-	if validate_metrics_name(metric_name) != nil {
-		log.Critical("RegisterMetricsSummary() error", map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name})
-		return nil
-	}
-	return ms.metrics_set_custom.GetOrCreateSummary(ms.get_metrics_name(metric_name, labels))
-}
-
-func (ms *MetricsSetup) RegisterMetricsHistogram(metric_name string, labels map[string]string) *metrics.Histogram {
-	if validate_metrics_name(metric_name) != nil {
-		log.Critical("RegisterMetricsHistogram() error", map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name})
-		return nil
-	}
-	return ms.metrics_set_custom.GetOrCreateHistogram(ms.get_metrics_name(metric_name, labels))
-}
-
-func (ms *MetricsSetup) Increment(metric_name string, labels map[string]string) {
-	ms.RegisterMetricsCounter(metric_name, labels).Inc()
-}
-
-func (ms *MetricsSetup) IncrementFloat(metric_name string, labels map[string]string, value float64) {
-	ms.RegisterFloatCounter(metric_name, labels).Add(value)
-}
-
-func (ms *MetricsSetup) Set(metric_name string, labels map[string]string, value uint64) {
-	ms.RegisterMetricsCounter(metric_name, labels).Set(value)
-}
-
-func (ms *MetricsSetup) Update(metric_name string, labels map[string]string, value float64) {
-	ms.RegisterMetricsHistogram(metric_name, labels).Update(value)
-}
-
-func (ms *MetricsSetup) UpdateDuration(metric_name string, labels map[string]string, value time.Time) {
-	ms.RegisterMetricsHistogram(metric_name, labels).UpdateDuration(value)
-}
-
-func (ms *MetricsSetup) UpdateSummary(metric_name string, labels map[string]string, value float64) {
-	ms.RegisterMetricsSummary(metric_name, labels).Update(value)
-}
-
-func (ms *MetricsSetup) RemoveMetrics(metric_name string, labels map[string]string) {
-	ms.metrics_set_custom.UnregisterMetric(ms.get_metrics_name(metric_name, labels))
-}
-
-func (ms *MetricsSetup) PurgeMetrics() {
-	ms.metrics_set_custom.UnregisterAllMetrics()
-}

monitoring/structs.go

@@ -1,14 +0,0 @@
-package libpack_monitoring
-
-const (
-	MetricsSucceeded     = "requests_succesful"
-	MetricsFailed        = "requests_failed"
-	MetricsDuration      = "requests_duration"
-	MetricsSkipped       = "requests_skipped"
-	MetricsExecutedQuery = "executed_query"
-	MetricsTimedQuery    = "timed_query"
-
-	MetricsCacheHit      = "cache_hit"
-	MetricsCacheMiss     = "cache_miss"
-	MetricsQueriesCached = "cached_queries"
-)

proxy.go

@@ -1,84 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"fmt"
-	"time"
-
-	"github.com/avast/retry-go/v4"
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/gofiber/fiber/v2/middleware/proxy"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-	"github.com/valyala/fasthttp"
-)
-
-func createFasthttpClient(timeout int) *fasthttp.Client {
-	return &fasthttp.Client{
-		Name:                     "graphql_proxy",
-		NoDefaultUserAgentHeader: true,
-		TLSConfig: &tls.Config{
-			InsecureSkipVerify: true,
-		},
-		MaxConnsPerHost:               2048,
-		ReadTimeout:                   time.Second * time.Duration(timeout),
-		WriteTimeout:                  time.Second * time.Duration(timeout),
-		MaxIdleConnDuration:           time.Second * time.Duration(timeout),
-		MaxConnDuration:               time.Second * time.Duration(timeout),
-		DisableHeaderNamesNormalizing: true,
-	}
-}
-
-func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
-	if !checkAllowedURLs(c) {
-		cfg.Logger.Error("Request blocked", map[string]interface{}{"path": c.Path()})
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-		}
-		c.Status(403).SendString("Request blocked - not allowed URL")
-		return nil
-	}
-	c.Request().Header.DisableNormalizing()
-	c.Request().Header.Add("X-Real-IP", c.IP())
-	c.Request().Header.Add(fiber.HeaderXForwardedFor, string(c.Request().Header.Peek("X-Forwarded-For")))
-	c.Request().Header.Del(fiber.HeaderAcceptEncoding)
-
-	cfg.Logger.Debug("Proxying the request", map[string]interface{}{"path": c.Path(), "body": string(c.Request().Body()), "headers": c.GetReqHeaders(), "request_uuid": c.Locals("request_uuid")})
-
-	err := retry.Do(
-		func() error {
-			errInt := proxy.DoRedirects(c, currentEndpoint+c.Path(), 3, cfg.Client.FastProxyClient)
-			if errInt != nil {
-				cfg.Logger.Error("Can't proxy the request", map[string]interface{}{"error": errInt.Error()})
-				if ifNotInTest() {
-					cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-				}
-				return errInt
-			}
-			return nil
-		},
-		retry.OnRetry(func(n uint, err error) {
-			cfg.Logger.Warning("Retrying the request", map[string]interface{}{"path": c.Path(), "error": err.Error()})
-		}),
-		retry.Attempts(uint(3)),
-		retry.DelayType(retry.BackOffDelay),
-		retry.Delay(time.Duration(250*time.Millisecond)),
-		retry.LastErrorOnly(true),
-	)
-
-	if err != nil {
-		cfg.Logger.Warning("Can't proxy the request", map[string]interface{}{"error": err.Error()})
-		return err
-	}
-
-	cfg.Logger.Debug("Received proxied response", map[string]interface{}{"path": c.Path(), "response_body": string(c.Response().Body()), "response_code": c.Response().StatusCode(), "headers": c.GetRespHeaders(), "request_uuid": c.Locals("request_uuid")})
-
-	if c.Response().StatusCode() != 200 {
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		}
-		return fmt.Errorf("Received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
-	}
-
-	c.Response().Header.Del(fiber.HeaderServer)
-	return nil
-}

proxy_test.go

@@ -1,97 +0,0 @@
-package main
-
-import (
-	"github.com/valyala/fasthttp"
-)
-
-func (suite *Tests) Test_proxyTheRequest() {
-
-	supplied_headers := map[string]string{
-		"X-Forwarded-For": "127.0.0.1",
-		"Content-Type":    "application/json",
-	}
-
-	tests := []struct {
-		headers map[string]string
-		name    string
-		body    string
-		host    string
-		hostRO  string
-		path    string
-		wantErr bool
-	}{
-		{
-			name:    "test_empty",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://telegram-bot.app/",
-			path:    "/v1/graphql",
-			headers: supplied_headers,
-			wantErr: false,
-		},
-		{
-			name:    "test_wrong_url",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://google.com/",
-			path:    "/v1/wrongURL",
-			headers: supplied_headers,
-			wantErr: true,
-		},
-		{
-			name:    "Test read only mode",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://google.com/",
-			hostRO:  "https://telegram-bot.app/",
-			path:    "/v1/graphql",
-			headers: supplied_headers,
-			wantErr: false,
-		},
-		{
-			name:    "Test read only mode wrong host",
-			body:    `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:    "https://telegram-bot.app/",
-			hostRO:  "https://google.com/",
-			path:    "/v1/graphql",
-			headers: supplied_headers,
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-
-			cfg = &config{}
-			parseConfig()
-			cfg.Server.HostGraphQL = tt.host
-
-			if tt.hostRO != "" {
-				cfg.Server.HostGraphQLReadOnly = tt.hostRO
-			}
-
-			ctx_headers := func() *fasthttp.RequestHeader {
-				h := fasthttp.RequestHeader{}
-				for k, v := range tt.headers {
-					h.Add(k, v)
-				}
-				return &h
-			}()
-
-			ctx_request := fasthttp.Request{
-				Header: *ctx_headers,
-			}
-			ctx_request.SetBody([]byte(tt.body))
-			ctx_request.SetRequestURI(tt.path)
-			ctx_request.Header.SetMethod("POST")
-			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{
-				Request: ctx_request,
-			})
-			res := parseGraphQLQuery(ctx)
-			assert.NotNil(ctx, "Fiber context is nil", tt.name)
-			err := proxyTheRequest(ctx, res.activeEndpoint)
-			if tt.wantErr {
-				assert.NotNil(err, "Error is nil", tt.name)
-			} else {
-				assert.Nil(err, "Error is not nil", tt.name)
-			}
-		})
-	}
-}

ratelimit.go

@@ -1,115 +0,0 @@
-package main
-
-import (
-	"os"
-	"time"
-
-	"github.com/goccy/go-json"
-
-	goratecounter "github.com/lukaszraczylo/go-ratecounter"
-)
-
-type RateLimitConfig struct {
-	RateCounterTicker *goratecounter.RateCounter
-	Interval          string `json:"interval"`
-	Req               int    `json:"req"`
-}
-
-var rateLimits map[string]RateLimitConfig
-var ratelimit_intervals = map[string]time.Duration{
-	"milli":  time.Millisecond,
-	"micro":  time.Microsecond,
-	"nano":   time.Nanosecond,
-	"second": time.Second,
-	"minute": time.Minute,
-	"hour":   time.Hour,
-	"day":    time.Hour * 24,
-}
-
-func loadRatelimitConfig() error {
-	paths := []string{"/go/src/app/ratelimit.json", "./ratelimit.json", "./static/app/default-ratelimit.json"}
-
-	for _, path := range paths {
-		err := loadConfigFromPath(path)
-		if err == nil {
-			return nil
-		}
-		cfg.Logger.Debug("Failed to load config", map[string]interface{}{"path": path, "error": err})
-	}
-
-	cfg.Logger.Error("Rate limit config not found", map[string]interface{}{"paths": paths})
-	return os.ErrNotExist
-}
-
-func loadConfigFromPath(path string) error {
-	file, err := os.Open(path)
-	if err != nil {
-		return err
-	}
-	defer file.Close()
-
-	config := struct {
-		RateLimit map[string]RateLimitConfig `json:"ratelimit"`
-	}{}
-
-	decoder := json.NewDecoder(file)
-	if err := decoder.Decode(&config); err != nil {
-		return err
-	}
-
-	for key, value := range config.RateLimit {
-		value.RateCounterTicker = goratecounter.NewRateCounter().WithConfig(goratecounter.RateCounterConfig{
-			Interval: time.Duration(value.Req) * ratelimit_intervals[value.Interval],
-		})
-		cfg.Logger.Debug("Setting ratelimit config for role", map[string]interface{}{
-			"role":              key,
-			"interval_provided": value.Interval,
-			"interval_used":     ratelimit_intervals[value.Interval],
-			"ratelimit":         value.Req,
-		})
-		config.RateLimit[key] = value
-	}
-
-	rateLimits = config.RateLimit
-	cfg.Logger.Debug("Rate limit config loaded", map[string]interface{}{"ratelimit": rateLimits})
-	return nil
-}
-
-func rateLimitedRequest(userID string, userRole string) (shouldAllow bool) {
-	if rateLimits == nil {
-		cfg.Logger.Debug("Rate limit config not found", map[string]interface{}{"user_role": userRole})
-		return true
-	}
-
-	// Fetch role config once to avoid multiple map lookups
-	roleConfig, ok := rateLimits[userRole]
-	if !ok {
-		cfg.Logger.Warning("Rate limit role not found", map[string]interface{}{"user_role": userRole})
-		return true
-	}
-
-	if roleConfig.RateCounterTicker == nil {
-		cfg.Logger.Warning("Rate limit ticker not found", map[string]interface{}{"user_role": userRole})
-		return true
-	}
-
-	roleConfig.RateCounterTicker.Incr(1)
-	tickerRate := roleConfig.RateCounterTicker.GetRate()
-
-	logDetails := map[string]interface{}{
-		"user_role":   userRole,
-		"user_id":     userID,
-		"rate":        tickerRate,
-		"config_rate": roleConfig.Req,
-		"interval":    roleConfig.Interval,
-	}
-
-	cfg.Logger.Debug("Rate limit ticker", logDetails)
-
-	if tickerRate > float64(roleConfig.Req) {
-		cfg.Logger.Debug("Rate limit exceeded", logDetails)
-		return false
-	}
-
-	return true
-}

semver.yaml

@@ -1,15 +0,0 @@
-version: 1
-force:
-  existing: true
-  strict: false
-  minor: 1
-wording:
-  patch:
-    - update
-    - initial
-    - fix
-  minor:
-    - improve
-    - release
-  major:
-    - breaking

server.go

@@ -1,232 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strconv"
-	"time"
-
-	"github.com/goccy/go-json"
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/gofiber/fiber/v2/middleware/cors"
-	"github.com/google/uuid"
-
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-)
-
-// StartHTTPProxy starts the HTTP and points it to the GraphQL server.
-func StartHTTPProxy() {
-	cfg.Logger.Debug("Starting the HTTP proxy", nil)
-	server := fiber.New(fiber.Config{
-		DisableStartupMessage: true,
-		AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
-		IdleTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second * 2,
-		ReadTimeout:           time.Duration(cfg.Client.ClientTimeout) * time.Second * 2,
-		WriteTimeout:          time.Duration(cfg.Client.ClientTimeout) * time.Second * 2,
-		JSONEncoder:           json.Marshal,
-		JSONDecoder:           json.Unmarshal,
-	})
-
-	server.Use(cors.New(cors.Config{
-		AllowOrigins: "*",
-	}))
-
-	// add middleware to check if the request is a GraphQL query
-	server.Use(AddRequestUUID)
-
-	server.Get("/healthz", healthCheck)
-	server.Get("/livez", healthCheck)
-
-	server.Post("/*", processGraphQLRequest)
-	server.Get("/*", proxyTheRequestToDefault)
-
-	cfg.Logger.Info("GraphQL query proxy started", map[string]interface{}{"port": cfg.Server.PortGraphQL})
-	err := server.Listen(fmt.Sprintf(":%d", cfg.Server.PortGraphQL))
-	if err != nil {
-		cfg.Logger.Critical("Can't start the service", map[string]interface{}{"error": err.Error()})
-	}
-}
-
-func proxyTheRequestToDefault(c *fiber.Ctx) error {
-	return proxyTheRequest(c, cfg.Server.HostGraphQL)
-}
-
-func AddRequestUUID(c *fiber.Ctx) error {
-	c.Locals("request_uuid", uuid.NewString())
-	return c.Next()
-}
-
-func checkAllowedURLs(c *fiber.Ctx) bool {
-	if len(allowedUrls) == 0 {
-		return true
-	}
-	_, ok := allowedUrls[c.Path()]
-	return ok
-}
-
-func healthCheck(c *fiber.Ctx) error {
-	if len(cfg.Server.HealthcheckGraphQL) > 0 {
-		cfg.Logger.Debug("Health check enabled", map[string]interface{}{"url": cfg.Server.HealthcheckGraphQL})
-		query := `{ __typename }`
-		_, err := cfg.Client.GQLClient.Query(query, nil, nil)
-		if err != nil {
-			cfg.Logger.Error("Can't reach the GraphQL server", map[string]interface{}{"error": err.Error()})
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-			c.Status(500).SendString("Can't reach the GraphQL server with {__typename} query")
-			return err
-		}
-	}
-	cfg.Logger.Debug("Health check returning OK", nil)
-	c.Status(200).SendString("Health check OK")
-	return nil
-}
-
-func processGraphQLRequest(c *fiber.Ctx) error {
-	startTime := time.Now()
-
-	// Initialize variables with default values
-	extractedUserID := "-"
-	extractedRoleName := "-"
-	var queryCacheHash string
-
-	authorization := c.Request().Header.Peek("Authorization")
-	if authorization != nil && (len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
-		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(string(authorization))
-	}
-
-	if checkIfUserIsBanned(c, extractedUserID) {
-		c.Status(403).SendString("User is banned")
-		return nil
-	}
-
-	if len(cfg.Client.RoleFromHeader) > 0 {
-		extractedRoleName = string(c.Request().Header.Peek(cfg.Client.RoleFromHeader))
-		if extractedRoleName == "" {
-			extractedRoleName = "-"
-		}
-	}
-
-	// Implementing rate limiting if enabled
-	if cfg.Client.RoleRateLimit {
-		cfg.Logger.Debug("Rate limiting enabled", map[string]interface{}{"user_id": extractedUserID, "role_name": extractedRoleName})
-		if !rateLimitedRequest(extractedUserID, extractedRoleName) {
-			c.Status(429).SendString("Rate limit exceeded, try again later")
-			return nil
-		}
-	}
-
-	parsedResult := parseGraphQLQuery(c)
-	if parsedResult.shouldBlock {
-		c.Status(403).SendString("Request blocked")
-		return nil
-	}
-
-	if parsedResult.shouldIgnore {
-		cfg.Logger.Debug("Request passed as-is - probably not a GraphQL", nil)
-		return proxyTheRequest(c, parsedResult.activeEndpoint)
-	}
-
-	calculatedQueryHash := calculateHash(c)
-
-	if parsedResult.cacheTime > 0 {
-		cfg.Logger.Debug("Cache time set via query", map[string]interface{}{"cacheTime": parsedResult.cacheTime})
-	} else {
-		// If not set via query, try setting via header
-		cacheQuery := c.Request().Header.Peek("X-Cache-Graphql-Query")
-		if cacheQuery != nil {
-			parsedResult.cacheTime, _ = strconv.Atoi(string(cacheQuery))
-			cfg.Logger.Debug("Cache time set via header", map[string]interface{}{"cacheTime": parsedResult.cacheTime})
-		} else {
-			parsedResult.cacheTime = cfg.Cache.CacheTTL
-		}
-	}
-
-	wasCached := false
-
-	if parsedResult.cacheRefresh {
-		cfg.Logger.Debug("Cache refresh requested via query", map[string]interface{}{"user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")})
-		cacheDelete(calculatedQueryHash)
-	}
-
-	// Handling Cache Logic
-	if parsedResult.cacheRequest || cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable {
-		cfg.Logger.Debug("Cache enabled", map[string]interface{}{"via_query": parsedResult.cacheRequest, "via_env": cfg.Cache.CacheEnable})
-		queryCacheHash = calculatedQueryHash
-
-		if cachedResponse := cacheLookup(queryCacheHash); cachedResponse != nil {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheHit, nil)
-			cfg.Logger.Debug("Cache hit", map[string]interface{}{"hash": queryCacheHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")})
-			c.Request().Header.Add("X-Cache-Hit", "true")
-			err := c.Send(cachedResponse)
-			if err != nil {
-				cfg.Logger.Error("Can't send the cached response", map[string]interface{}{"error": err.Error()})
-				cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-				c.Status(500).SendString("Can't send the cached response - try again later")
-			}
-			wasCached = true
-		} else {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
-			cfg.Logger.Debug("Cache miss", map[string]interface{}{"hash": queryCacheHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")})
-			proxyAndCacheTheRequest(c, queryCacheHash, parsedResult.cacheTime, parsedResult.activeEndpoint)
-		}
-	} else {
-		err := proxyTheRequest(c, parsedResult.activeEndpoint)
-		if err != nil {
-			cfg.Logger.Error("Can't proxy the request", map[string]interface{}{"error": err.Error()})
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-			c.Status(500).SendString("Can't proxy the request - try again later")
-			return nil
-		}
-	}
-
-	timeTaken := time.Since(startTime)
-
-	// Logging & Monitoring
-	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, timeTaken, startTime)
-
-	return nil
-}
-
-// Additional helper function to avoid code repetition
-func proxyAndCacheTheRequest(c *fiber.Ctx, queryCacheHash string, cacheTime int, currentEndpoint string) {
-	err := proxyTheRequest(c, currentEndpoint)
-	if err != nil {
-		cfg.Logger.Error("Can't proxy the request", map[string]interface{}{"error": err.Error()})
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		c.Status(500).SendString("Can't proxy the request - try again later")
-		return
-	}
-	cacheStoreWithTTL(queryCacheHash, c.Response().Body(), time.Duration(cacheTime)*time.Second)
-	cfg.Monitoring.Increment(libpack_monitoring.MetricsQueriesCached, nil)
-	c.Send(c.Response().Body())
-}
-
-func logAndMonitorRequest(c *fiber.Ctx, userID, opType, opName string, wasCached bool, duration time.Duration, startTime time.Time) {
-	labels := map[string]string{
-		"op_type": opType,
-		"op_name": opName,
-		"cached":  fmt.Sprintf("%t", wasCached),
-		"user_id": userID,
-	}
-
-	if cfg.Server.AccessLog {
-		cfg.Logger.Info("Request processed", map[string]interface{}{
-			"ip":           c.IP(),
-			"fwd-ip":       string(c.Request().Header.Peek("X-Forwarded-For")),
-			"user_id":      userID,
-			"op_type":      opType,
-			"op_name":      opName,
-			"time":         duration,
-			"cache":        wasCached,
-			"request_uuid": c.Locals("request_uuid"),
-		})
-	}
-
-	cfg.Monitoring.Increment(libpack_monitoring.MetricsSucceeded, nil)
-	cfg.Monitoring.Increment(libpack_monitoring.MetricsExecutedQuery, labels)
-
-	if !wasCached {
-		cfg.Monitoring.UpdateDuration(libpack_monitoring.MetricsTimedQuery, labels, startTime)
-		cfg.Monitoring.Update(libpack_monitoring.MetricsTimedQuery, labels, float64(duration.Milliseconds()))
-	}
-}

static/app/banned_users.json

@@ -1 +0,0 @@
-{}

static/app/ratelimit.json

@@ -1,16 +0,0 @@
-{
-  "ratelimit": {
-      "admin": {
-          "req": 100,
-          "interval": "second"
-      },
-      "guest": {
-          "req": 3,
-          "interval": "second"
-      },
-      "-": {
-          "req": 100,
-          "interval": "hour"
-      }
-  }
-}

static/kubernetes-deployment.yaml

@@ -1,92 +0,0 @@
----
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: hasura-proxy-internal
-  labels:
-    app: hasura-proxy-internal
-    type: support
-spec:
-  replicas: 2
-  selector:
-    matchLabels:
-      app: hasura-proxy-internal
-      type: support
-  template:
-    metadata:
-      labels:
-        app: hasura-proxy-internal
-        type: support
-      annotations:
-        prometheus.io/scrape: "true"
-        prometheus.io/port: "9393"
-        prometheus.io/path: "/metrics"
-    spec:
-      securityContext:
-        runAsUser: 65534 # nobody
-      affinity:
-        nodeAffinity:
-          requiredDuringSchedulingIgnoredDuringExecution:
-            nodeSelectorTerms:
-            - matchExpressions:
-              - key: node-role.kubernetes.io/worker
-                operator: Exists
-      containers:
-      - name: graphql-proxy
-        image: ghcr.io/lukaszraczylo/graphql-monitoring-proxy:latest
-        imagePullPolicy: Always
-        resources:
-          limits:
-            cpu: "1"
-            memory: "640Mi"
-          requests:
-            cpu: "0.75"
-            memory: "512Mi"
-        livenessProbe:
-          httpGet:
-            path: /healthz
-            port: 8080
-          initialDelaySeconds: 5
-        ports:
-          - name: web
-            containerPort: 8080
-          - name: monitoring
-            containerPort: 9393
-        env:
-          - name: PORT_GRAPHQL
-            value: "8080"
-          - name: MONITORING_PORT
-            value: "9393"
-          - name: HOST_GRAPHQL
-            value: http://hasura-internal:8080/v1/graphql
-          - name: ENABLE_GLOBAL_CACHE
-            value: "true"
-          - name: CACHE_TTL
-            value: "10"
-          - name: BLOCK_SCHEMA_INTROSPECTION
-            value: "true"
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: hasura-proxy-internal
-  labels:
-    app: hasura-proxy-internal
-    type: support
-  annotations:
-    prometheus.io/scrape: "true"
-    prometheus.io/port: "9393"
-    prometheus.io/path: "/metrics"
-spec:
-  ports:
-  - name: web
-    port: 8080
-    targetPort: 8080
-  - name: monitoring
-    port: 9393
-    targetPort: 9393
-  selector:
-    app: hasura-proxy-internal
-    type: support
-  type: ClusterIP

static/kubernetes-single-deployment-with-ro.yaml

@@ -1,165 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: hasura-w-proxy-internal
-  labels:
-    app: hasura-w-proxy-internal
-    type: support
-spec:
-  replicas: 2
-  selector:
-    matchLabels:
-      app: hasura-w-proxy-internal
-      type: support
-  template:
-    metadata:
-      labels:
-        app: hasura-w-proxy-internal
-        type: support
-    spec:
-      securityContext:
-        runAsUser: 65534 # nobody
-      affinity:
-        nodeAffinity:
-          requiredDuringSchedulingIgnoredDuringExecution:
-            nodeSelectorTerms:
-              - matchExpressions:
-                  - key: node-role.kubernetes.io/worker
-                    operator: Exists
-      containers:
-        - name: hasura
-          image: hasura/graphql-engine:v2.33.1-ce
-          ports:
-            - name: hasura-internal
-              containerPort: 8080
-          livenessProbe:
-            httpGet:
-              path: /healthz
-              port: 8080
-            initialDelaySeconds: 30
-          resources:
-            limits:
-              cpu: "1"
-              memory: "640Mi"
-            requests:
-              cpu: "0.75"
-              memory: "512Mi"
-          env:
-            - name: HASURA_GRAPHQL_DATABASE_URL
-              value: postgres://postgres:xxx@yyy:5432/postgres
-            - name: HASURA_GRAPHQL_ENABLE_CONSOLE
-              value: "true"
-            - name: HASURA_GRAPHQL_DEV_MODE
-              value: "true"
-            - name: HASURA_GRAPHQL_ENABLE_TELEMETRY
-              value: "false"
-            - name: HASURA_GRAPHQL_EXPERIMENTAL_FEATURES
-              value: "inherited_roles"
-            - name: HASURA_GRAPHQL_PG_CONNECTIONS
-              value: "20"
-            - name: HASURA_GRAPHQL_LOG_LEVEL
-              value: "error"
-
-        - name: hasura-ro
-          image: hasura/graphql-engine:v2.33.1-ce
-          ports:
-            - name: hasura-internal-ro
-              containerPort: 8088
-          livenessProbe:
-            httpGet:
-              path: /healthz
-              port: 8088
-            initialDelaySeconds: 30
-          resources:
-            limits:
-              cpu: "1"
-              memory: "640Mi"
-            requests:
-              cpu: "0.75"
-              memory: "512Mi"
-          env:
-            - name: HASURA_GRAPHQL_DATABASE_URL
-              value: postgres://postgres:[email protected]:5432/postgres
-              # POINT METADATA TO THE RW database (!!!)
-            - name: HASURA_GRAPHQL_METADATA_DATABASE_URL
-              value: postgres://postgres:xxx@yyy:5432/postgres
-            - name: HASURA_GRAPHQL_ENABLE_CONSOLE
-              value: "true"
-            - name: HASURA_GRAPHQL_DEV_MODE
-              value: "true"
-            - name: HASURA_GRAPHQL_ENABLE_TELEMETRY
-              value: "false"
-            - name: HASURA_GRAPHQL_EXPERIMENTAL_FEATURES
-              value: "inherited_roles"
-            - name: HASURA_GRAPHQL_PG_CONNECTIONS
-              value: "20"
-            - name: HASURA_GRAPHQL_LOG_LEVEL
-              value: "error"
-            - name: HASURA_GRAPHQL_SERVER_PORT
-              value: "8088"
-
-        - name: graphql-proxy
-          image: ghcr.io/lukaszraczylo/graphql-monitoring-proxy:latest
-          imagePullPolicy: Always
-          resources:
-            limits:
-              cpu: "1"
-              memory: "640Mi"
-            requests:
-              cpu: "0.75"
-              memory: "128Mi"
-          livenessProbe:
-            httpGet:
-              path: /healthz
-              port: 8080
-            initialDelaySeconds: 5
-            timeoutSeconds: 5
-          ports:
-            - name: web
-              containerPort: 8181
-            - name: monitoring
-              containerPort: 9393
-          env:
-            - name: PORT_GRAPHQL
-              value: "8181"
-            - name: MONITORING_PORT
-              value: "9393"
-            - name: HOST_GRAPHQL
-              value: http://localhost:8080/
-            - name: HOST_GRAPHQL_READONLY
-              value: http://localhost:8088/
-            - name: ENABLE_GLOBAL_CACHE
-              value: "true"
-            - name: CACHE_TTL
-              value: "10"
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: hasura-w-proxy-internal
-  labels:
-    app: hasura-w-proxy-internal
-    type: support
-  annotations:
-    prometheus.io/scrape: "true"
-    prometheus.io/port: "9393"
-    prometheus.io/path: "/metrics"
-spec:
-  ports:
-    - name: hasura
-      port: 8080
-      targetPort: 8080
-    - name: hasura-ro
-      port: 8088
-      targetPort: 8088
-    - name: proxy
-      port: 8181
-      targetPort: 8181
-    - name: monitoring
-      port: 9393
-      targetPort: 9393
-  selector:
-    app: hasura-w-proxy-internal
-    type: support
-  type: ClusterIP

static/kubernetes-single-deployment.yaml

@@ -1,121 +0,0 @@
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: hasura-w-proxy-internal
-  labels:
-    app: hasura-w-proxy-internal
-    type: support
-spec:
-  replicas: 2
-  selector:
-    matchLabels:
-      app: hasura-w-proxy-internal
-      type: support
-  template:
-    metadata:
-      labels:
-        app: hasura-w-proxy-internal
-        type: support
-    spec:
-      securityContext:
-        runAsUser: 65534 # nobody
-      affinity:
-        nodeAffinity:
-          requiredDuringSchedulingIgnoredDuringExecution:
-            nodeSelectorTerms:
-            - matchExpressions:
-              - key: node-role.kubernetes.io/worker
-                operator: Exists
-      containers:
-      - name: hasura
-        image: hasura/graphql-engine:v2.33.1-ce
-        ports:
-          - name: hasura-internal
-            containerPort: 8080
-        livenessProbe:
-          httpGet:
-            path: /healthz
-            port: 8080
-          initialDelaySeconds: 30
-        resources:
-          limits:
-            cpu: "1"
-            memory: "640Mi"
-          requests:
-            cpu: "0.75"
-            memory: "512Mi"
-        env:
-          - name: HASURA_GRAPHQL_DATABASE_URL
-            value: postgres://postgres:xxx@yyy:5432/postgres
-          - name: HASURA_GRAPHQL_ENABLE_CONSOLE
-            value: "true"
-          - name: HASURA_GRAPHQL_DEV_MODE
-            value: "true"
-          - name: HASURA_GRAPHQL_ENABLE_TELEMETRY
-            value: "false"
-          - name: HASURA_GRAPHQL_EXPERIMENTAL_FEATURES
-            value: "inherited_roles"
-          - name: HASURA_GRAPHQL_PG_CONNECTIONS
-            value: "20"
-          - name: HASURA_GRAPHQL_LOG_LEVEL
-            value: "error"
-      - name: graphql-proxy
-        image: ghcr.io/lukaszraczylo/graphql-monitoring-proxy:latest
-        imagePullPolicy: Always
-        resources:
-          limits:
-            cpu: "1"
-            memory: "640Mi"
-          requests:
-            cpu: "0.75"
-            memory: "128Mi"
-        livenessProbe:
-          httpGet:
-            path: /healthz
-            port: 8080
-          initialDelaySeconds: 5
-          timeoutSeconds: 5
-        ports:
-          - name: web
-            containerPort: 8181
-          - name: monitoring
-            containerPort: 9393
-        env:
-          - name: PORT_GRAPHQL
-            value: "8181"
-          - name: MONITORING_PORT
-            value: "9393"
-          - name: HOST_GRAPHQL
-            value: http://localhost:8080/
-          - name: ENABLE_GLOBAL_CACHE
-            value: "true"
-          - name: CACHE_TTL
-            value: "10"
-
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: hasura-w-proxy-internal
-  labels:
-    app: hasura-w-proxy-internal
-    type: support
-  annotations:
-    prometheus.io/scrape: "true"
-    prometheus.io/port: "9393"
-    prometheus.io/path: "/metrics"
-spec:
-  ports:
-  - name: hasura
-    port: 8080
-    targetPort: 8080
-  - name: proxy
-    port: 8181
-    targetPort: 8181
-  - name: monitoring
-    port: 9393
-    targetPort: 9393
-  selector:
-    app: hasura-w-proxy-internal
-    type: support
-  type: ClusterIP

struct_config.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	graphql "github.com/lukaszraczylo/go-simple-graphql"
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-	"github.com/valyala/fasthttp"
-)
-
-// config is a struct that holds the configuration of the application.
-type config struct {
-	Logger     *libpack_logging.LogConfig
-	Monitoring *libpack_monitoring.MetricsSetup
-	Api        struct{ BannedUsersFile string }
-	Client     struct {
-		GQLClient        *graphql.BaseClient
-		FastProxyClient  *fasthttp.Client
-		JWTUserClaimPath string
-		JWTRoleClaimPath string
-		RoleFromHeader   string
-		proxy            string
-		ClientTimeout    int
-		RoleRateLimit    bool
-	}
-	Security struct {
-		IntrospectionAllowed []string
-		BlockIntrospection   bool
-	}
-	HasuraEventCleaner struct {
-		EventMetadataDb string
-		ClearOlderThan  int
-		Enable          bool
-	}
-	Cache struct {
-		Client             CacheClient
-		CacheRedisURL      string
-		CacheRedisPassword string
-		CacheTTL           int
-		CacheRedisDB       int
-		CacheEnable        bool
-		CacheRedisEnable   bool
-	}
-	Server struct {
-		HostGraphQL         string
-		HostGraphQLReadOnly string
-		HealthcheckGraphQL  string
-		AllowURLs           []string
-		PortGraphQL         int
-		PortMonitoring      int
-		ApiPort             int
-		PurgeEvery          int
-		AccessLog           bool
-		ReadOnlyMode        bool
-		EnableApi           bool
-		PurgeOnCrawl        bool
-	}
-}