add Benchmark (go) benchmark result for da8ec5f21d

.github/FUNDING.yml

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

.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,9 +0,0 @@
-FROM alpine:latest
-RUN apk add --no-cache ca-certificates
-WORKDIR /go/src/app
-ARG TARGETARCH
-ARG TARGETOS
-ADD dist/bot-$TARGETOS-$TARGETARCH /go/src/app/graphql-proxy
-ADD static/default-ratelimit.json /app/ratelimit.json
-RUN chmod +x /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 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)
 
@@ -15,6 +15,9 @@ This project is in active use by [telegram-bot.app](https://telegram-bot.app), a
   - [Configuration](#configuration)
   - [Speed](#speed)
     - [Caching](#caching)
+    - [Read-only endpoint](#read-only-endpoint)
+  - [Maintenance](#maintenance)
+    - [Hasura event cleaner](#hasura-event-cleaner)
   - [Security](#security)
     - [Role-based rate limiting](#role-based-rate-limiting)
     - [Read-only mode](#read-only-mode)
@@ -22,7 +25,9 @@ This project is in active use by [telegram-bot.app](https://telegram-bot.app), a
     - [Blocking introspection](#blocking-introspection)
   - [API endpoints](#api-endpoints)
     - [Ban or unban the user](#ban-or-unban-the-user)
+    - [Cache operations](#cache-operations)
   - [General](#general)
+    - [Metrics which matter](#metrics-which-matter)
     - [Healthcheck](#healthcheck)
     - [Monitoring endpoint](#monitoring-endpoint)
 
@@ -92,20 +97,27 @@ In this case, both proxy and websockets will be available under the `/v1/graphql
 | monitor    | Extracting the query name and type and adding it as a label to metrics|
 | monitor    | Calculating the query duration and adding it to the metrics           |
 | speed      | Caching the queries, together with per-query cache and TTL            |
+| speed      | Support for READ ONLY graphql endpoint                                |
 | security   | Blocking schema introspection                                         |
 | security   | Rate limiting queries based on user role                              |
 | security   | Blocking mutations in read-only mode                                  |
 | security   | Allow access only to listed URLs                                      |
 | security   | Ban / unban specific user from accessing the application              |
+| maintenance | Hasura event cleaner                                                 |
 
 
 ### Configuration
 
+All the environment variables **should** be prefixed with `GMP_` to avoid conflicts with other applications.
+If `GMP_` prefixed environment variable is present - it will take precedence over the non-prefixed one.
+You can still use the non-prefixed environment variables in the spirit of the backward compatibility, but it's not recommended.
+
 | Parameter                 | Description                              | Default Value              |
 |---------------------------|------------------------------------------|----------------------------|
 | `MONITORING_PORT`         | The port to expose the metrics endpoint  | `9393`                     |
 | `PORT_GRAPHQL`            | The port to expose the graphql endpoint  | `8080`                     |
 | `HOST_GRAPHQL`            | The host to proxy the graphql endpoint   | `http://localhost/` |
+| `HOST_GRAPHQL_READONLY`   | The host to proxy the read-only graphql endpoint | ``               |
 | `HEALTHCHECK_GRAPHQL_URL` | The URL to check the health of the graphql endpoint | `` |
 | `JWT_USER_CLAIM_PATH`     | Path to the user claim in the JWT token  | ``                         |
 | `JWT_ROLE_CLAIM_PATH`     | Path to the role claim in the JWT token  | ``                         |
@@ -113,6 +125,10 @@ In this case, both proxy and websockets will be available under the `/v1/graphql
 | `ROLE_RATE_LIMIT`         | Enable request rate limiting based on role| `false`                   |
 | `ENABLE_GLOBAL_CACHE`     | Enable the cache                        | `false`                    |
 | `CACHE_TTL`               | The cache TTL                           | `60`                       |
+| `ENABLE_REDIS_CACHE`      | Enable distributed Redis cache          | `false`                    |
+| `CACHE_REDIS_URL`         | URL to redis server / cluster endpoint  | `localhost:6379`           |
+| `CACHE_REDIS_PASSWORD`    | Redis connection password               | ``                         |
+| `CACHE_REDIS_DB`          | Redis DB id                             | `0`                        |
 | `LOG_LEVEL`               | The log level                           | `info`                     |
 | `BLOCK_SCHEMA_INTROSPECTION`| Blocks the schema introspection       | `false`                    |
 | `ALLOWED_INTROSPECTION`  | Allow only certain queries in introspection | ``                  |
@@ -123,18 +139,57 @@ In this case, both proxy and websockets will be available under the `/v1/graphql
 | `API_PORT`                | The port to expose the monitoring API   | `9090`                     |
 | `BANNED_USERS_FILE`       | The path to the file with banned users  | `/go/src/app/banned_users.json`   |
 | `PROXIED_CLIENT_TIMEOUT` | The timeout for the proxied client in seconds     | `120`                      |
+| `PURGE_METRICS_ON_CRAWL` | Purge metrics on each /metrics crawl    | `false`                      |
+| `PURGE_METRICS_ON_TIMER` | Purge metrics every x seconds. `0` - disabled | `0`                      |
+| `HASURA_EVENT_CLEANER`   | Enable the hasura event cleaner          | `false`                    |
+| `HASURA_EVENT_CLEANER_OLDER_THAN` | The interval for the hasura event cleaner (in days) | `1`                  |
+| `HASURA_EVENT_METADATA_DB` | URL to the hasura metadata database    | `postgresql://localhost:5432/hasura` |
 
 ### Speed
 
 #### Caching
 
 The cache engine is enabled in the background by default, using no additional resources.
-You can then start using the cache by setting the `ENABLE_GLOBAL_CACHE` environment variable to `true` - which will enable the cache for all queries without introspection. You can leave the global cache disabled and enable the cache for specific queries by adding the `@cached` directive to the query.
+You can then start using the cache by setting the `ENABLE_GLOBAL_CACHE` or `ENABLE_REDIS_CACHE` environment variable to `true` - which will enable the cache for all queries without introspection. You can leave the global cache disabled and enable the cache for specific queries by adding the `@cached` directive to the query.
 
 In the case of the `@cached` you can add additional parameters to the directive which will set the cache for specific queries to the provided time.
 For example, `query MyCachedQuery @cached(ttl: 90) ....` will set the cache for the query to 90 seconds.
 
+You can also set cache for specific query by using `X-Cache-Graphql-Query` header, which will set the cache for the query to the provided time, for example `X-Cache-Graphql-Query: 90` will set the cache for the query to 90 seconds.
+
+You can also force refresh of the cache by using `@cached(refresh: true)` directive in the query, for example:
+
+```
+query MyProducts @cached(refresh: true) {
+  products {
+    id
+    name
+  }
+}
+```
+
 Since version `0.5.30` the cache is gzipped in the memory, which should optimise the memory usage quite significantly.
+Since version `0.15.48` the you can also use the distributed Redis cache.
+
+#### Read-only endpoint
+
+You can now specify the read-only GraphQL endpoint by setting the `HOST_GRAPHQL_READONLY` environment variable. The default value is empty, preventing the proxy from using the read-only endpoint for the queries and directing all the requests to the main endpoint specified as `HOST_GRAPHQL`. If the `HOST_GRAPHQL_READONLY` is set, the proxy will use the read-only endpoint for the queries with the `query` type and the main endpoint for the `mutation` type queries. Format of the read-only endpoint is the same as `HOST_GRAPHQL` endpoint, for example `http://localhost:8080/`.
+
+You can check out the [example of combined deployment with RW and read-only hasura](static/kubernetes-single-deployment-with-ro.yaml).
+
+### Maintenance
+
+#### Hasura event cleaner
+
+When enabled via `HASURA_EVENT_CLEANER=true` - proxy needs to have a direct access to the database to execute simple delete queries on schedule. You can specify number of days the logs should be kept for using `HASURA_EVENT_CLEANER_OLDER_THAN`, for example `HASURA_EVENT_CLEANER_OLDER_THAN=14` will keep 14 days of event execution logs. Ticker managing the cleaner routine will be executed every hour.
+
+Following tables are being cleaned:
+- `hdb_catalog.event_invocation_logs`
+- `hdb_catalog.event_log`
+- `hdb_catalog.hdb_action_log`
+- `hdb_catalog.hdb_cron_event_invocation_logs`
+- `hdb_catalog.hdb_scheduled_event_invocation_logs`
+
 
 ### Security
 
@@ -207,6 +262,11 @@ To do so - you need to enable the api by setting env variable `ENABLE_API=true`
 * `POST /api/user-ban` - ban the user from accessing the application
 * `POST /api/user-unban` - unban the user from accessing the application
 
+#### Cache operations
+
+* `POST /api/cache-clear` - clear the cache
+* `GET /api/cache-stats` - get the cache statistics ( hits, misses, size )
+
 Both endpoints require the `user_id` parameter to be present in the request body and allow you to provide the reason for the ban.
 
 Example request:
@@ -225,6 +285,14 @@ Ban details will be stored in the `banned_users.json` file, which you can mount
 
 ### General
 
+#### Metrics which matter
+
+You can always enable `PURGE_METRICS_ON_CRAWL` environment variable to purge the metrics on each `/metrics` crawl. This will allow you to see only the current metrics, without potential leftovers from the previous crawls. This is useful if you want to monitor the metrics in real-time and / or limit the amount of data ingested into the monitoring system. When enabled you will most likely need to update your monitoring queries.
+
+With the `PURGE_METRICS_ON_CRAWL` enabled, the `graphql_proxy_requests_failed`, `graphql_proxy_requests_skipped` and `graphql_proxy_requests_succesful` metrics will remain between resets.
+
+If you prefer more control over the metrics purging - you can enable `PURGE_METRICS_ON_TIMER` environment variable and set the interval in seconds. This will allow you to purge the metrics on a regular basis, for example every 90 seconds. It could be better solution if you have multiple crawlers checking the metrics endpoints and you want to avoid the situation when metrics are purged by for example healthcheck.
+
 #### Healthcheck
 
 If you'd like the `/healthz` endpoint to perform actual check for the connectivity to the graphql endpoint - set the `HEALTHCHECK_GRAPHQL_URL` environment variable to the exact URL of the graphql endpoint. The query executed will be `query { __typename }` and if the response is not `200 OK` - the healthcheck will fail. Remember that the endpoint is a full URL which you'd like to check, so it should include the protocol, host and path - for example `http://localhost:8080/v1/graphql` and it's NOT the same as value of `HOST_GRAPHQL` environment variable which should provide only the host, without path, ending with slash.
@@ -246,4 +314,7 @@ graphql_proxy_executed_query{user_id="-",op_type="query",op_name="checkIfSpamAIR
 graphql_proxy_requests_failed 324
 graphql_proxy_requests_skipped 0
 graphql_proxy_requests_succesful 454823
+graphql_proxy_cache_hit{microservice="graphql_proxy",pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc"} 7
+graphql_proxy_cache_hit{pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc",microservice="graphql_proxy"} 1
+graphql_proxy_cache_miss{microservice="graphql_proxy",pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc"} 23
 ```

api.go

@@ -1,133 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"time"
-
-	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)
-
-		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
-}
-
-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
-		}
-	}
-
-	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,25 +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"
-)
-
-func calculateHash(c *fiber.Ctx) string {
-	return strutil.Md5(c.Body())
-}
-
-func enableCache() {
-	cfg.Cache.CacheClient = libpack_cache.New(time.Duration(cfg.Cache.CacheTTL) * time.Second * 100)
-}
-
-func cacheLookup(hash string) []byte {
-	obj, found := cfg.Cache.CacheClient.Get(hash)
-	if found {
-		return obj
-	}
-	return nil
-}

cache/cache.go

@@ -1,145 +0,0 @@
-package libpack_cache
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-	"sync"
-	"time"
-)
-
-type CacheEntry struct {
-	Value     []byte
-	ExpiresAt time.Time
-}
-
-type Cache struct {
-	sync.RWMutex
-	entries   sync.Map
-	globalTTL time.Duration
-	bytePool  sync.Pool
-}
-
-func New(globalTTL time.Duration) *Cache {
-	cache := &Cache{
-		globalTTL: globalTTL,
-	}
-
-	// Initialize the byte pool.
-	cache.bytePool.New = func() interface{} {
-		return make([]byte, 0)
-	}
-
-	// Start the cache cleanup.
-	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 {
-		return
-	}
-
-	// Get a byte slice from the pool and ensure it's properly sized.
-	b := c.bytePool.Get().([]byte)
-	if cap(b) < len(compressedValue) {
-		b = make([]byte, len(compressedValue))
-	} else {
-		b = b[:len(compressedValue)]
-	}
-
-	copy(b, compressedValue)
-
-	entry := CacheEntry{
-		Value:     b,
-		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 {
-		return nil, false
-	}
-
-	return value, true
-}
-
-func (c *Cache) Delete(key string) {
-	c.Lock()
-	defer c.Unlock()
-
-	entry, ok := c.entries.Load(key)
-	if !ok {
-		return
-	}
-
-	// Return the byte slice to the pool.
-	c.bytePool.Put(entry.(CacheEntry).Value)
-
-	// Delete the entry from the cache.
-	c.entries.Delete(key)
-}
-
-func (c *Cache) CleanExpiredEntries() {
-	now := time.Now()
-	c.entries.Range(func(key, value interface{}) bool {
-		entry := value.(CacheEntry)
-		if entry.ExpiresAt.Before(now) {
-			// Return the byte slice to the pool.
-			c.bytePool.Put(entry.Value)
-
-			// Delete the entry from the cache.
-			c.entries.Delete(key)
-		}
-
-		// Return true to continue iterating over the map.
-		return true
-	})
-}
-
-func (c *Cache) compress(data []byte) ([]byte, error) {
-	var buf bytes.Buffer
-	w := gzip.NewWriter(&buf)
-	_, err := w.Write(data)
-	if err != nil {
-		return nil, err
-	}
-	err = w.Close()
-	if err != nil {
-		return nil, err
-	}
-	return buf.Bytes(), nil
-}
-
-func (c *Cache) decompress(data []byte) ([]byte, error) {
-	r, err := gzip.NewReader(bytes.NewBuffer(data))
-	if err != nil {
-		return nil, err
-	}
-	defer r.Close()
-	return io.ReadAll(r)
-}

cache/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_test.go

@@ -1,49 +0,0 @@
-package main
-
-import (
-	"testing"
-	"time"
-)
-
-func (suite *Tests) Test_cacheLookup() {
-	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.T().Run(tt.name, func(t *testing.T) {
-			if tt.addCache.data != nil {
-				cfg.Cache.CacheClient.Set(tt.args.hash, tt.addCache.data, time.Duration(90*time.Second))
-			}
-			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,52 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"fmt"
-	"strings"
-
-	"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,83 +0,0 @@
-package main
-
-import "testing"
-
-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.T().Run(tt.name, func(t *testing.T) {
-			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>

go.mod

@@ -1,50 +0,0 @@
-module github.com/lukaszraczylo/graphql-monitoring-proxy
-
-go 1.21
-
-require (
-	github.com/VictoriaMetrics/metrics v1.24.0
-	github.com/buger/jsonparser v1.1.1
-	github.com/gofiber/fiber/v2 v2.50.0
-	github.com/gofrs/flock v0.8.1
-	github.com/google/uuid v1.3.1
-	github.com/gookit/goutil v0.6.14
-	github.com/graphql-go/graphql v0.8.1
-	github.com/json-iterator/go v1.1.12
-	github.com/lukaszraczylo/ask v0.0.0-20230927103145-2ff1123b4415
-	github.com/lukaszraczylo/go-ratecounter v0.1.8
-	github.com/lukaszraczylo/go-simple-graphql v1.1.37
-	github.com/rs/zerolog v1.31.0
-	github.com/stretchr/testify v1.8.4
-	github.com/valyala/fasthttp v1.50.0
-)
-
-require (
-	github.com/andybalholm/brotli v1.0.6 // indirect
-	github.com/avast/retry-go/v4 v4.5.0 // indirect
-	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/gookit/color v1.5.4 // indirect
-	github.com/klauspost/compress v1.17.2 // 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/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
-	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/rivo/uniseg v0.4.4 // 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/exp v0.0.0-20231006140011-7918f672742d // indirect
-	golang.org/x/net v0.17.0 // indirect
-	golang.org/x/sync v0.4.0 // indirect
-	golang.org/x/sys v0.13.0 // indirect
-	golang.org/x/term v0.13.0 // indirect
-	golang.org/x/text v0.13.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect
-	gopkg.in/yaml.v3 v3.0.1 // indirect
-)

go.sum

@@ -1,106 +0,0 @@
-github.com/VictoriaMetrics/metrics v1.24.0 h1:ILavebReOjYctAGY5QU2F9X0MYvkcrG3aEn2RKa1Zkw=
-github.com/VictoriaMetrics/metrics v1.24.0/go.mod h1:eFT25kvsTidQFHb6U0oa0rTrDRdz4xTYjpL8+UPohys=
-github.com/andybalholm/brotli v1.0.6 h1:Yf9fFpf49Zrxb9NlQaluyE92/+X7UVHlhMNJN2sxfOI=
-github.com/andybalholm/brotli v1.0.6/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
-github.com/avast/retry-go/v4 v4.5.0 h1:QoRAZZ90cj5oni2Lsgl2GW8mNTnUCnmpx/iKpwVisHg=
-github.com/avast/retry-go/v4 v4.5.0/go.mod h1:7hLEXp0oku2Nir2xBAsg0PTphp9z71bN5Aq1fboC3+I=
-github.com/buger/jsonparser v1.1.1 h1:2PnMjfWD7wBILjqQbt530v576A/cAbQvEW9gGIpYMUs=
-github.com/buger/jsonparser v1.1.1/go.mod h1:6RYKKt7H4d4+iWqouImQ9R2FZql3VbhNgx27UK13J/0=
-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/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
-github.com/gofiber/fiber/v2 v2.50.0 h1:ia0JaB+uw3GpNSCR5nvC5dsaxXjRU5OEu36aytx+zGw=
-github.com/gofiber/fiber/v2 v2.50.0/go.mod h1:21eytvay9Is7S6z+OgPi7c7n4++tnClWmhpimVHMimw=
-github.com/gofrs/flock v0.8.1 h1:+gYjHKf32LDeiEEFhQaotPbLuUXjY5ZqxKgXy7n59aw=
-github.com/gofrs/flock v0.8.1/go.mod h1:F1TvTiK9OcQqauNUHlbJvyl9Qa1QvF/gOUDKA14jxHU=
-github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
-github.com/google/uuid v1.3.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4=
-github.com/google/uuid v1.3.1/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.14 h1:96elyOG4BvVoDaiT7vx1vHPrVyEtFfYlPPBODR0/FGQ=
-github.com/gookit/goutil v0.6.14/go.mod h1:YyDBddefmjS+mU2PDPgCcjVzTDM5WgExiDv5ZA/b8I8=
-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/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
-github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/klauspost/compress v1.17.2 h1:RlWWUY/Dr4fL8qk9YG7DTZ7PDgME2V4csBXA8L/ixi4=
-github.com/klauspost/compress v1.17.2/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
-github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
-github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
-github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-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.1.37 h1:8emnfzWTApitNQ+hMHMPeGljL/xlVf/u8oKt26bUXDs=
-github.com/lukaszraczylo/go-simple-graphql v1.1.37/go.mod h1:0d/x8hj9Uus4qiv981fjL56jw8DutJ6WAeTsNWClZ/Y=
-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/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
-github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
-github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
-github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
-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/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.4 h1:8TfxU8dW6PdqD27gjM8MVNuicgxIjxpm4K7x4jp8sis=
-github.com/rivo/uniseg v0.4.4/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.31.0 h1:FcTR3NnLWW+NnTwwhFWiJSZr4ECLpqCm6QsEnyvbV4A=
-github.com/rs/zerolog v1.31.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.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
-github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
-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.50.0 h1:H7fweIlBm0rXLs2q0XbalvJ6r0CUPFWK3/bB4N13e9M=
-github.com/valyala/fasthttp v1.50.0/go.mod h1:k2zXd82h/7UZc3VOdJ2WaUqt1uZ/XpXAfE9i+HBC3lA=
-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/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.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM=
-golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE=
-golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ=
-golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
-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.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE=
-golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/term v0.13.0 h1:bb+I9cTfFazGW51MZqBVmZy7+JEJMouUHTUSKVQLBek=
-golang.org/x/term v0.13.0/go.mod h1:LTmsnFJwVN6bCy1rVCoS+qHT1HhALEFxKncY3WNNh4U=
-golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
-golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
-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.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

graphql.go

@@ -1,121 +0,0 @@
-package main
-
-import (
-	"strconv"
-	"strings"
-
-	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 retrospection_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 retrospectionQuerySet = make(map[string]struct{}, len(retrospection_queries))
-
-func parseGraphQLQuery(c *fiber.Ctx) (operationType, operationName string, cacheRequest bool, cache_time int, should_block bool, should_ignore bool) {
-	should_ignore = true
-	m := make(map[string]interface{})
-	err := json.Unmarshal(c.Body(), &m)
-	if err != nil {
-		cfg.Logger.Debug("Can't unmarshal the request", map[string]interface{}{"error": err.Error(), "body": string(c.Body())})
-		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})
-		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})
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		return
-	}
-
-	should_ignore = false
-	operationName = "undefined"
-	for _, d := range p.Definitions {
-		if oper, ok := d.(*ast.OperationDefinition); ok {
-			operationType = oper.Operation
-			if strings.ToLower(operationType) == "mutation" && cfg.Server.ReadOnlyMode {
-				cfg.Logger.Warning("Mutation blocked", m)
-				cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-				c.Status(403).SendString("The server is in read-only mode")
-				should_block = true
-				return
-			}
-
-			if oper.Name != nil {
-				operationName = oper.Name.Value
-			} else {
-				operationName = "undefined"
-			}
-			for _, dir := range oper.Directives {
-				if dir.Name.Value == "cached" {
-					cacheRequest = true
-					for _, arg := range dir.Arguments {
-						if arg.Name.Value == "ttl" {
-							cache_time, err = strconv.Atoi(arg.Value.GetValue().(string))
-							if err != nil {
-								cfg.Logger.Error("Can't parse the ttl", map[string]interface{}{"ttl": arg.Value.GetValue().(string)})
-								cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-								return
-							}
-						}
-					}
-				}
-			}
-			if cfg.Security.BlockIntrospection {
-				for _, s := range oper.SelectionSet.Selections {
-					for _, s2 := range s.GetSelectionSet().Selections {
-						if _, exists := retrospectionQuerySet[strings.ToLower(s2.(*ast.Field).Name.Value)]; exists {
-							if len(cfg.Security.IntrospectionAllowed) > 0 {
-								for _, introspectionQueryAllowed := range cfg.Security.IntrospectionAllowed {
-									if strings.EqualFold(strings.ToLower(introspectionQueryAllowed), strings.ToLower(s2.(*ast.Field).Name.Value)) {
-										cfg.Logger.Debug("Introspection query allowed, passing through", m)
-										return
-									}
-								}
-							}
-							cfg.Logger.Warning("Introspection query blocked", m)
-							cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-							c.Status(403).SendString("Introspection queries are not allowed")
-							should_block = true
-							return
-						}
-					}
-				}
-			}
-		}
-	}
-
-	return
-}

logging/logging.go

@@ -1,90 +0,0 @@
-package libpack_logging
-
-import (
-	"io"
-	"os"
-	"time"
-
-	"github.com/gookit/goutil/envutil"
-	"github.com/rs/zerolog"
-)
-
-type LogConfig struct {
-	logger zerolog.Logger
-}
-
-var baseLogger zerolog.Logger
-
-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()
-}
-
-func NewLogger() *LogConfig {
-	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)
-	}
-
-	return &LogConfig{logger: baseLogger}
-}
-
-func (lw *LogConfig) log(w io.Writer, level zerolog.Level, message string, v map[string]interface{}) {
-	e := lw.logger.With().Logger()
-	e = e.Output(w)
-	event := e.WithLevel(level).CallerSkipFrame(3)
-	for k, val := range v {
-		switch v := val.(type) {
-		case string:
-			event.Str(k, v)
-		case int:
-			event.Int(k, v)
-		case float64:
-			event.Float64(k, v)
-		default:
-			event.Interface(k, val)
-		}
-	}
-	event.Msg(message)
-}
-
-func (lw *LogConfig) Debug(message string, v ...map[string]interface{}) {
-	lw.log(os.Stdout, zerolog.DebugLevel, message, mergeMaps(v))
-}
-
-func (lw *LogConfig) Info(message string, v ...map[string]interface{}) {
-	lw.log(os.Stdout, zerolog.InfoLevel, message, mergeMaps(v))
-}
-
-func (lw *LogConfig) Warning(message string, v ...map[string]interface{}) {
-	lw.log(os.Stdout, zerolog.WarnLevel, message, mergeMaps(v))
-}
-
-func (lw *LogConfig) Error(message string, v ...map[string]interface{}) {
-	lw.log(os.Stderr, zerolog.ErrorLevel, message, mergeMaps(v))
-}
-
-func (lw *LogConfig) Critical(message string, v ...map[string]interface{}) {
-	lw.log(os.Stderr, zerolog.FatalLevel, message, mergeMaps(v))
-	os.Exit(1)
-}
-
-func mergeMaps(maps []map[string]interface{}) map[string]interface{} {
-	result := make(map[string]interface{})
-	for _, m := range maps {
-		for k, v := range m {
-			result[k] = v
-		}
-	}
-	return result
-}

logging/logging_bench_test.go

@@ -1,31 +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()
-	for i := 0; i < b.N; i++ {
-		testsLogger.Info("test", map[string]interface{}{"test": "test"})
-	}
-}

logging/logging_test.go

@@ -1,373 +0,0 @@
-package libpack_logging
-
-import (
-	"errors"
-	"io"
-	"os"
-	"reflect"
-	"testing"
-
-	"github.com/buger/jsonparser"
-	"github.com/stretchr/testify/suite"
-)
-
-type LoggingTestSuite struct {
-	suite.Suite
-}
-
-var (
-	testsLogger *LogConfig
-)
-
-type stdoutCapture struct {
-	oldStdout *os.File
-	readPipe  *os.File
-}
-
-func (sc *stdoutCapture) StartCapture() {
-	sc.oldStdout = os.Stdout
-	sc.readPipe, os.Stdout, _ = os.Pipe()
-}
-
-func (sc *stdoutCapture) StopCapture() (string, error) {
-	if sc.oldStdout == nil || sc.readPipe == nil {
-		return "", errors.New("StartCapture not called before StopCapture on Stdout")
-	}
-	os.Stdout.Close()
-	os.Stdout = sc.oldStdout
-	bytes, err := io.ReadAll(sc.readPipe)
-	if err != nil {
-		return "", err
-	}
-	return string(bytes), nil
-}
-
-type stderrCapture struct {
-	oldStderr *os.File
-	readPipe  *os.File
-}
-
-func (sc *stderrCapture) StartCapture() {
-	sc.oldStderr = os.Stderr
-	sc.readPipe, os.Stderr, _ = os.Pipe()
-}
-
-func (sc *stderrCapture) StopCapture() (string, error) {
-	if sc.oldStderr == nil || sc.readPipe == nil {
-		return "", errors.New("StartCapture not called before StopCapture on Stderr")
-	}
-	os.Stderr.Close()
-	os.Stderr = sc.oldStderr
-	bytes, err := io.ReadAll(sc.readPipe)
-	if err != nil {
-		return "", err
-	}
-	return string(bytes), nil
-}
-
-func (suite *LoggingTestSuite) SetupTest() {
-}
-
-func TestLoggingTestSuite(t *testing.T) {
-	suite.Run(t, new(LoggingTestSuite))
-}
-
-func (suite *LoggingTestSuite) TestLogConfig_AllHandlers() {
-	type args struct {
-		message string
-	}
-	tests := []struct {
-		name           string
-		args           args
-		wantLevel      string
-		wantMessage    string
-		envMinLogLevel string
-		loggerType     string
-		stdOutExpect   bool
-		stdErrExpect   bool
-	}{
-		{
-			name:       "Test log: Error",
-			loggerType: "Error",
-			args: args{
-				message: "This is a error message",
-			},
-			wantLevel:    "error",
-			wantMessage:  "This is a error message",
-			stdErrExpect: true,
-			stdOutExpect: false,
-		},
-		{
-			name:       "Test log: Warning",
-			loggerType: "Warning",
-			args: args{
-				message: "This is a warning message",
-			},
-			wantLevel:      "warn",
-			wantMessage:    "This is a warning message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "info",
-		},
-		{
-			name:       "Test log: Warning | Min level: Debug",
-			loggerType: "Warning",
-			args: args{
-				message: "This is a warning message",
-			},
-			wantLevel:      "warn",
-			wantMessage:    "This is a warning message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "debug",
-		},
-		{
-			name:       "Test log: Info",
-			loggerType: "Info",
-			args: args{
-				message: "This is a info message",
-			},
-			wantLevel:    "info",
-			wantMessage:  "This is a info message",
-			stdErrExpect: false,
-			stdOutExpect: true,
-		},
-		{
-			name:       "Test log: Info | Min level: Warn",
-			loggerType: "Info",
-			args: args{
-				message: "This is a info message",
-			},
-			wantLevel:      "",
-			wantMessage:    "",
-			stdErrExpect:   false,
-			stdOutExpect:   false,
-			envMinLogLevel: "warn",
-		},
-		{
-			name:       "Test log: Warning | Min level: Warn",
-			loggerType: "Warning",
-			args: args{
-				message: "This is a warning message",
-			},
-			wantLevel:      "warn",
-			wantMessage:    "This is a warning message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "warn",
-		},
-		{
-			name:       "Test log: Warning | Min level: Error",
-			loggerType: "Warning",
-			args: args{
-				message: "This is an error message",
-			},
-			wantLevel:      "",
-			wantMessage:    "",
-			stdErrExpect:   false,
-			stdOutExpect:   false,
-			envMinLogLevel: "error",
-		},
-		{
-			name:       "Test log: Debug | Min level: Debug",
-			loggerType: "Debug",
-			args: args{
-				message: "This is a debug message",
-			},
-			wantLevel:      "debug",
-			wantMessage:    "This is a debug message",
-			stdErrExpect:   false,
-			stdOutExpect:   true,
-			envMinLogLevel: "debug",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			if tt.envMinLogLevel != "" {
-				os.Setenv("LOG_LEVEL", tt.envMinLogLevel)
-				defer os.Unsetenv("LOG_LEVEL")
-			}
-			testsLogger = NewLogger()
-
-			captureStdout := stdoutCapture{}
-			captureStdout.StartCapture()
-			captureStderr := stderrCapture{}
-			captureStderr.StartCapture()
-
-			reflect.ValueOf(testsLogger).MethodByName(tt.loggerType).Call([]reflect.Value{reflect.ValueOf(tt.args.message)})
-
-			stdoutOut, err := captureStdout.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			stderrOut, err := captureStderr.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			if tt.stdErrExpect && !tt.stdOutExpect {
-				gotLvl, gotMsg, err := getResponseValues(stderrOut, "short_message")
-				suite.NoError(err, "Failed in [STDERR]: "+tt.name)
-				suite.Equal(tt.wantLevel, gotLvl, "Failed in [STDERR]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDERR]: "+tt.name)
-				suite.Equal("", stdoutOut, "Failed in [STDERR]: "+tt.name)
-			}
-			if tt.stdOutExpect && !tt.stdErrExpect {
-				gotLvl, gotMsg, err := getResponseValues(stdoutOut, "short_message")
-				suite.NoError(err, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal(tt.wantLevel, gotLvl, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal("", stderrOut, "Failed in [STDOUT]: "+tt.name)
-			}
-			if !tt.stdErrExpect && !tt.stdOutExpect {
-				suite.Equal("", stderrOut, "Failed in [NEITHER]: "+tt.name)
-				suite.Equal("", stdoutOut, "Failed in [NEITHER]: "+tt.name)
-			}
-			os.Unsetenv("LOG_LEVEL")
-		})
-	}
-}
-
-func (suite *LoggingTestSuite) TestFullMessage() {
-	type args struct {
-		extraFields map[string]interface{}
-		message     string
-	}
-	extraFields := make(map[string]interface{})
-	extraFields["_full_message"] = "full message"
-
-	tests := []struct {
-		args           args
-		name           string
-		wantLevel      string
-		wantMessage    string
-		envMinLogLevel string
-		loggerType     string
-		stdOutExpect   bool
-		stdErrExpect   bool
-	}{
-		{
-			name:       "Test log: Error",
-			loggerType: "Error",
-			args: args{
-				message:     "This is a error message",
-				extraFields: extraFields,
-			},
-			wantLevel:    "error",
-			wantMessage:  extraFields["_full_message"].(string),
-			stdErrExpect: true,
-			stdOutExpect: false,
-		},
-		{
-			name:       "Test log: Info",
-			loggerType: "Info",
-			args: args{
-				message:     "This is a info message",
-				extraFields: extraFields,
-			},
-			wantMessage:  extraFields["_full_message"].(string),
-			stdErrExpect: false,
-			stdOutExpect: true,
-		},
-	}
-
-	for _, tt := range tests {
-		suite.T().Run(tt.name, func(t *testing.T) {
-			if tt.envMinLogLevel != "" {
-				os.Setenv("LOG_LEVEL", tt.envMinLogLevel)
-				defer os.Unsetenv("LOG_LEVEL")
-			}
-			testsLogger = NewLogger()
-
-			captureStdout := stdoutCapture{}
-			captureStdout.StartCapture()
-			captureStderr := stderrCapture{}
-			captureStderr.StartCapture()
-
-			reflect.ValueOf(testsLogger).MethodByName(tt.loggerType).Call([]reflect.Value{
-				reflect.ValueOf(tt.args.message),
-				reflect.ValueOf(tt.args.extraFields),
-			})
-
-			stdoutOut, err := captureStdout.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			stderrOut, err := captureStderr.StopCapture()
-			if err != nil {
-				suite.T().Fatal(err)
-			}
-
-			if tt.stdErrExpect && !tt.stdOutExpect {
-				_, gotMsg, err := getResponseValues(stderrOut, "_full_message")
-				suite.NoError(err, "Failed in [STDERR]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDERR]: "+tt.name)
-			}
-			if tt.stdOutExpect && !tt.stdErrExpect {
-				_, gotMsg, err := getResponseValues(stdoutOut, "_full_message")
-				suite.NoError(err, "Failed in [STDOUT]: "+tt.name)
-				suite.Equal(tt.wantMessage, gotMsg, "Failed in [STDOUT]: "+tt.name)
-			}
-			os.Unsetenv("LOG_LEVEL")
-		})
-	}
-}
-
-func Test_getResponseValues(t *testing.T) {
-	type args struct {
-		sourceJson string
-	}
-	tests := []struct {
-		name       string
-		args       args
-		wantGotLvl string
-		wantGotMsg string
-		wantErr    bool
-	}{
-		{
-			name: "Test with json",
-			args: args{
-				sourceJson: `{"level": "debug", "short_message": "hello world"`,
-			},
-			wantGotLvl: "debug",
-			wantGotMsg: "hello world",
-			wantErr:    false,
-		},
-		{
-			name: "Test with json, wrong message field",
-			args: args{
-				sourceJson: `{"level": "debug", "message": "hello world"`,
-			},
-			wantGotLvl: "debug",
-			wantGotMsg: "",
-			wantErr:    true,
-		},
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotGotLvl, gotGotMsg, err := getResponseValues(tt.args.sourceJson, "short_message")
-			if (err != nil) != tt.wantErr {
-				t.Errorf("getResponseValues() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			if gotGotLvl != tt.wantGotLvl {
-				t.Errorf("getResponseValues() gotGotLvl = %v, want %v", gotGotLvl, tt.wantGotLvl)
-			}
-			if gotGotMsg != tt.wantGotMsg {
-				t.Errorf("getResponseValues() gotGotMsg = %v, want %v", gotGotMsg, tt.wantGotMsg)
-			}
-		})
-	}
-}
-
-func getResponseValues(sourceJson string, key string) (gotLvl, gotMsg string, err error) {
-	gotLvl, err = jsonparser.GetString([]byte(sourceJson), "level")
-	if err != nil {
-		return
-	}
-	gotMsg, err = jsonparser.GetString([]byte(sourceJson), key)
-	return
-}

main.go

@@ -1,68 +0,0 @@
-package main
-
-import (
-	"strings"
-
-	"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
-
-func init() {
-	for _, query := range retrospection_queries {
-		retrospectionQuerySet[query] = struct{}{}
-	}
-}
-
-func parseConfig() {
-	libpack_config.PKG_NAME = "graphql_proxy"
-	var c config
-	c.Server.PortGraphQL = envutil.GetInt("PORT_GRAPHQL", 8080)
-	c.Server.PortMonitoring = envutil.GetInt("MONITORING_PORT", 9393)
-	c.Server.HostGraphQL = envutil.Getenv("HOST_GRAPHQL", "http://localhost/")
-	c.Client.JWTUserClaimPath = envutil.Getenv("JWT_USER_CLAIM_PATH", "")
-	c.Client.JWTRoleClaimPath = envutil.Getenv("JWT_ROLE_CLAIM_PATH", "")
-	c.Client.RoleFromHeader = envutil.Getenv("ROLE_FROM_HEADER", "")
-	c.Client.RoleRateLimit = envutil.GetBool("ROLE_RATE_LIMIT", false)
-	c.Cache.CacheEnable = envutil.GetBool("ENABLE_GLOBAL_CACHE", false)
-	c.Cache.CacheTTL = envutil.GetInt("CACHE_TTL", 60)
-	c.Security.BlockIntrospection = envutil.GetBool("BLOCK_SCHEMA_INTROSPECTION", false)
-	c.Security.IntrospectionAllowed = func() []string {
-		urls := envutil.Getenv("ALLOWED_INTROSPECTION", "")
-		if urls == "" {
-			return nil
-		}
-		return strings.Split(urls, ",")
-	}()
-	c.Logger = libpack_logging.NewLogger()
-	c.Server.HealthcheckGraphQL = envutil.Getenv("HEALTHCHECK_GRAPHQL_URL", "")
-	c.Client.GQLClient = graphql.NewConnection()
-	c.Client.GQLClient.SetEndpoint(c.Server.HealthcheckGraphQL)
-	c.Server.AccessLog = envutil.GetBool("ENABLE_ACCESS_LOG", false)
-	c.Server.ReadOnlyMode = envutil.GetBool("READ_ONLY_MODE", false)
-	c.Server.AllowURLs = func() []string {
-		urls := envutil.Getenv("ALLOWED_URLS", "")
-		if urls == "" {
-			return nil
-		}
-		return strings.Split(urls, ",")
-	}()
-	c.Client.ClientTimeout = envutil.GetInt("PROXIED_CLIENT_TIMEOUT", 120)
-	c.Client.FastProxyClient = createFasthttpClient(c.Client.ClientTimeout)
-	c.Server.EnableApi = envutil.GetBool("ENABLE_API", false)
-	c.Server.ApiPort = envutil.GetInt("API_PORT", 9090)
-	c.Api.BannedUsersFile = envutil.Getenv("BANNED_USERS_FILE", "/go/src/app/banned_users.json")
-	cfg = &c
-	enableCache() // takes close to no resources, but can be used with dynamic query cache
-	loadRatelimitConfig()
-	enableApi()
-}
-
-func main() {
-	parseConfig()
-	StartMonitoringServer()
-	StartHTTPProxy()
-}

main_test.go

@@ -1,32 +0,0 @@
-package main
-
-import (
-	"testing"
-
-	assertions "github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type Tests struct {
-	suite.Suite
-}
-
-var (
-	assert *assertions.Assertions
-)
-
-func (suite *Tests) SetupTest() {
-	assert = assertions.New(suite.T())
-}
-
-func (suite *Tests) BeforeTest(suiteName, testName string) {
-}
-
-// func (suite *Tests) AfterTest(suiteName, testName string) {)
-
-func TestSuite(t *testing.T) {
-	cfg = &config{}
-	parseConfig()
-	StartMonitoringServer()
-	suite.Run(t, new(Tests))
-}

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()
-	cfg.Monitoring.AddMetricsPrefix("graphql_proxy")
-	cfg.Monitoring.RegisterDefaultMetrics()
-}

monitoring/defaults.go

@@ -1,12 +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)
-}
-
-func (ms *MetricsSetup) RegisterGoMetrics() {
-	// TODO: metrics.WriteProcessMetrics(ms.metrics_set)
-}

monitoring/helpers.go

@@ -1,57 +0,0 @@
-package libpack_monitoring
-
-import (
-	"fmt"
-	"strings"
-
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-)
-
-func (ms *MetricsSetup) get_metrics_name(name string, labels map[string]string) (complete_name string) {
-	if labels == nil {
-		labels = make(map[string]string)
-	}
-	labels["microservice"] = libpack_config.PKG_NAME
-
-	if ms.metrics_prefix != "" {
-		complete_name = ms.metrics_prefix + "_" + name
-	} else {
-		complete_name = name
-	}
-	if labels != nil {
-		complete_name += "{"
-		for k, v := range labels {
-			complete_name += k + "=\"" + v + "\","
-		}
-		complete_name = strings.TrimSuffix(complete_name, ",")
-		complete_name += "}"
-	}
-	return
-}
-
-// 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 {
-	// replace all spaces with underscores and remove all other non-alphanumeric characters
-	name_new := strings.ReplaceAll(name, " ", "_")
-	name_new = strings.Map(func(r rune) rune {
-		if (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9') || r == '_' {
-			return r
-		}
-		return -1
-	}, name_new)
-	name_new = strings.ReplaceAll(name_new, "__", "_")
-	name_new = strings.Trim(name_new, "_")
-	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 {
-	metric_name := name
-	for k, v := range labels {
-		metric_name += "_" + k + "_" + v
-	}
-	return metric_name
-}

monitoring/monitoring.go

@@ -1,132 +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 (
-	"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_prefix string
-	metrics_set    *metrics.Set
-}
-
-var (
-	log *logging.LogConfig
-)
-
-func NewMonitoring() *MetricsSetup {
-	log = logging.NewLogger()
-	ms := &MetricsSetup{}
-	ms.metrics_set = metrics.NewSet()
-	go ms.startPrometheusEndpoint()
-	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())
-	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.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
-	}
-	return ms.metrics_set.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.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.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.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.UnregisterMetric(ms.get_metrics_name(metric_name, labels))
-}
-
-func (ms *MetricsSetup) PurgeMetrics() {
-	ms.metrics_set.UnregisterAllMetrics()
-}

monitoring/structs.go

@@ -1,8 +0,0 @@
-package libpack_monitoring
-
-const (
-	MetricsSucceeded = "requests_succesful"
-	MetricsFailed    = "requests_failed"
-	MetricsDuration  = "requests_duration"
-	MetricsSkipped   = "requests_skipped"
-)

proxy.go

@@ -1,57 +0,0 @@
-package main
-
-import (
-	"crypto/tls"
-	"fmt"
-	"time"
-
-	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:               200,
-		ReadTimeout:                   time.Second * time.Duration(timeout),
-		WriteTimeout:                  time.Second * time.Duration(timeout),
-		DisableHeaderNamesNormalizing: true,
-	}
-}
-
-func proxyTheRequest(c *fiber.Ctx) error {
-	if !checkAllowedURLs(c) {
-		cfg.Logger.Error("Request blocked", map[string]interface{}{"path": c.Path()})
-		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")))
-
-	proxy.WithClient(cfg.Client.FastProxyClient)
-
-	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 := proxy.DoRedirects(c, cfg.Server.HostGraphQL+c.Path(), 3)
-	if err != nil {
-		cfg.Logger.Error("Can't proxy the request", map[string]interface{}{"error": err.Error()})
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-		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 {
-		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
-}

ratelimit.go

@@ -1,113 +0,0 @@
-package main
-
-import (
-	"os"
-	"time"
-
-	goratecounter "github.com/lukaszraczylo/go-ratecounter"
-)
-
-type RateLimitConfig struct {
-	Req               int    `json:"req"`
-	Interval          string `json:"interval"`
-	RateCounterTicker *goratecounter.RateCounter
-}
-
-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{"/app/ratelimit.json", "./ratelimit.json", "./static/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")
-	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,16 +0,0 @@
-version: 1
-force:
-  existing: true
-  strict: false
-  minor: 1
-wording:
-  patch:
-    - update
-    - initial
-    - fix
-  minor:
-    - change
-    - improve
-    - release
-  major:
-    - breaking

server.go

@@ -1,195 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/gofiber/fiber/v2/middleware/cors"
-	"github.com/google/uuid"
-
-	jsoniter "github.com/json-iterator/go"
-	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-)
-
-var json = jsoniter.ConfigCompatibleWithStandardLibrary
-
-// StartHTTPProxy starts the HTTP and points it to the GraphQL server.
-func StartHTTPProxy() {
-	server := fiber.New(fiber.Config{
-		DisableStartupMessage: true,
-		AppName:               fmt.Sprintf("GraphQL Monitoring Proxy - %s v%s", libpack_config.PKG_NAME, libpack_config.PKG_VERSION),
-	})
-
-	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("/*", proxyTheRequest)
-
-	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 AddRequestUUID(c *fiber.Ctx) error {
-	c.Locals("request_uuid", uuid.NewString())
-	return c.Next()
-}
-
-func checkAllowedURLs(c *fiber.Ctx) bool {
-	if len(cfg.Server.AllowURLs) == 0 {
-		return true
-	}
-	for _, allowedURL := range cfg.Server.AllowURLs {
-		if c.Path() == allowedURL {
-			return true
-		}
-	}
-	return false
-}
-
-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")
-	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) {
-		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
-		}
-	}
-
-	opType, opName, cacheFromQuery, cache_time, shouldBlock, should_ignore := parseGraphQLQuery(c)
-	if shouldBlock {
-		return nil
-	}
-
-	if should_ignore {
-		cfg.Logger.Debug("Request passed as-is - not a GraphQL")
-		return proxyTheRequest(c)
-	}
-
-	if cache_time > 0 {
-		cfg.Logger.Debug("Cache time set via query", map[string]interface{}{"cache_time": cache_time})
-		cache_time = cfg.Cache.CacheTTL
-	}
-
-	wasCached := false
-
-	// Handling Cache Logic
-	if cacheFromQuery || cfg.Cache.CacheEnable {
-		cfg.Logger.Debug("Cache enabled", map[string]interface{}{"via_query": cacheFromQuery, "via_env": cfg.Cache.CacheEnable})
-		queryCacheHash = calculateHash(c)
-
-		if cachedResponse := cacheLookup(queryCacheHash); cachedResponse != nil {
-			cfg.Logger.Debug("Cache hit", map[string]interface{}{"hash": queryCacheHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")})
-			c.Send(cachedResponse)
-			wasCached = true
-		} else {
-			cfg.Logger.Debug("Cache miss", map[string]interface{}{"hash": queryCacheHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")})
-			proxyAndCacheTheRequest(c, queryCacheHash, cache_time)
-		}
-	} else {
-		proxyTheRequest(c)
-	}
-
-	timeTaken := time.Since(startTime)
-
-	// Logging & Monitoring
-	logAndMonitorRequest(c, extractedUserID, opType, opName, wasCached, timeTaken, startTime)
-
-	return nil
-}
-
-// Additional helper function to avoid code repetition
-func proxyAndCacheTheRequest(c *fiber.Ctx, queryCacheHash string, cache_time int) {
-	err := proxyTheRequest(c)
-	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
-	}
-	cfg.Cache.CacheClient.Set(queryCacheHash, c.Response().Body(), time.Duration(cache_time)*time.Second)
-	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("executed_query", labels)
-
-	if !wasCached {
-		cfg.Monitoring.UpdateDuration("timed_query", labels, startTime)
-		cfg.Monitoring.Update("timed_query", labels, float64(duration.Milliseconds()))
-	}
-}

static/default-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.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,54 +0,0 @@
-package main
-
-import (
-	graphql "github.com/lukaszraczylo/go-simple-graphql"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	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
-
-	// Server holds the configuration of the server _ONLY_.
-	Server struct {
-		PortGraphQL        int
-		PortMonitoring     int
-		HostGraphQL        string
-		HealthcheckGraphQL string
-		AccessLog          bool
-		ReadOnlyMode       bool
-		AllowURLs          []string
-		EnableApi          bool
-		ApiPort            int
-	}
-
-	Client struct {
-		JWTUserClaimPath string
-		JWTRoleClaimPath string
-		RoleRateLimit    bool
-		RoleFromHeader   string
-		GQLClient        *graphql.BaseClient
-		FastProxyClient  *fasthttp.Client
-		proxy            string
-		ClientTimeout    int
-	}
-
-	Cache struct {
-		CacheEnable bool
-		CacheTTL    int
-		CacheClient *libpack_cache.Cache
-	}
-
-	Api struct {
-		BannedUsersFile string
-	}
-
-	Security struct {
-		BlockIntrospection   bool
-		IntrospectionAllowed []string
-	}
-}