Add appropriate labels to the container

.github/workflows/autoupdate.yaml

@@ -5,13 +5,69 @@ on:
   schedule:
     - cron: "0 3 * * *"
 
-permissions:
-  contents: write
-  actions: write
+env:
+  GO_VERSION: ">=1.21"
 
 jobs:
-  autoupdate:
-    uses: lukaszraczylo/shared-actions/.github/workflows/go-autoupdate.yaml@main
-    with:
-      go-version: "1.24"
-      release-workflow: "release.yaml"
+  # This job is responsible for preparation of the build
+  # environment variables.
+  prepare:
+    name: Preparing build context
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        id: cache
+        with:
+          go-version: ${{env.GO_VERSION}}
+          cache-dependency-path: "**/*.sum"
+
+      - name: Go get dependencies
+        if: steps.cache.outputs.cache-hit != 'true'
+        run: |
+          go get ./...
+
+  # This job is responsible for running tests and linting the codebase
+  test:
+    name: "Unit testing"
+    runs-on: ubuntu-latest
+    container: golang:1
+    needs: [prepare]
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Ensure full history is checked out
+          token: ${{ secrets.GHCR_TOKEN }}
+
+      - name: Install Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{env.GO_VERSION}}
+          cache-dependency-path: "**/*.sum"
+
+      - name: Install dependencies
+        run: |
+          apt-get update
+          apt-get install ca-certificates make -y
+          update-ca-certificates
+          go mod tidy
+          go get -u -v ./...
+          go mod tidy -v
+
+      - name: Run unit tests
+        run: |
+          CI_RUN=${CI} make test
+          git config --global --add safe.directory /__w/graphql-monitoring-proxy/graphql-monitoring-proxy
+
+      - name: Commit changes
+        uses: stefanzweifel/git-auto-commit-action@v5
+        with:
+          commit_message: "Update go.mod and go.sum"
+          commit_options: "--no-verify --signoff"
+          file_pattern: "go.mod go.sum"

.github/workflows/pr.yaml

@@ -105,5 +105,5 @@ jobs:
           summary-always: true
           # auto-push only if it's on main branch
           auto-push: false
-          gh-pages-branch: "main"
-          benchmark-data-dir-path: "docs/bench"
+          gh-pages-branch: "gh-pages"
+          benchmark-data-dir-path: "docs"

.github/workflows/release.yaml

@@ -1,60 +0,0 @@
-name: Release
-
-on:
-  workflow_dispatch:
-  push:
-    paths-ignore:
-      - "**.md"
-      - "**/release.yaml"
-      - "static/**"
-      - "docs/**"
-    branches:
-      - main
-
-permissions:
-  contents: write
-  packages: write
-  deployments: write
-
-jobs:
-  release:
-    uses: lukaszraczylo/shared-actions/.github/workflows/go-release.yaml@main
-    with:
-      go-version: "1.24"
-      docker-enabled: true
-    secrets: inherit
-
-  benchmark:
-    name: Publish Benchmarks
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup Go
-        uses: actions/setup-go@v5
-        with:
-          go-version: "1.24"
-
-      - name: Run benchmarks
-        run: go test -bench=. -benchmem ./... -run=^# | tee output.txt
-
-      - name: Store benchmark result
-        uses: benchmark-action/github-action-benchmark@v1
-        with:
-          tool: "go"
-          output-file-path: output.txt
-          fail-on-alert: true
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          comment-on-alert: true
-          summary-always: true
-          auto-push: false
-          benchmark-data-dir-path: "docs/bench"
-
-      - name: Push benchmark results
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git add docs/bench
-          git diff --staged --quiet || git commit -m "Update benchmark results"
-          git push

.github/workflows/test.yaml

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

.gitignore

@@ -1,7 +1,4 @@
 graphql-proxy
 test.sh
 banned.json*
-dist/
-coverage.out
-CLAUDE.md
-graphql-monitoring-proxy
+dist/

.goreleaser.yaml

@@ -1,67 +0,0 @@
-version: 2
-
-before:
-  hooks:
-    - go mod tidy
-
-builds:
-  - id: graphql-proxy
-    main: .
-    binary: graphql-proxy
-    env:
-      - CGO_ENABLED=0
-    goos:
-      - linux
-      - darwin
-      - windows
-    goarch:
-      - amd64
-      - arm64
-    ldflags:
-      - -s -w
-
-archives:
-  - id: graphql-proxy
-    formats: [tar.gz]
-    name_template: "graphql-proxy-{{ .Os }}-{{ .Arch }}"
-    format_overrides:
-      - goos: windows
-        formats: [zip]
-    files:
-      - LICENSE
-      - README.md
-
-checksum:
-  name_template: "graphql-proxy-checksums.txt"
-  algorithm: sha256
-
-changelog:
-  sort: asc
-  filters:
-    exclude:
-      - '^docs:'
-      - '^test:'
-      - '^Merge'
-      - '^WIP'
-      - '^Update go.mod'
-
-release:
-  github:
-    owner: lukaszraczylo
-    name: graphql-monitoring-proxy
-  name_template: "version {{.Version}}"
-  draft: false
-  prerelease: auto
-
-dockers_v2:
-  - images:
-      - "ghcr.io/lukaszraczylo/graphql-monitoring-proxy"
-    tags:
-      - "{{ .Version }}"
-      - "latest"
-    platforms:
-      - linux/amd64
-      - linux/arm64
-    dockerfile: Dockerfile.goreleaser
-    extra_files:
-      - static/app

CODEOWNERS

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

Dockerfile

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

Dockerfile.goreleaser

@@ -1,6 +0,0 @@
-FROM gcr.io/distroless/base-debian12:nonroot
-ARG TARGETPLATFORM
-WORKDIR /go/src/app
-COPY --chmod=777 --chown=nonroot:nonroot static/app /go/src/app
-COPY ${TARGETPLATFORM}/graphql-proxy /go/src/app/graphql-proxy
-ENTRYPOINT ["/go/src/app/graphql-proxy"]

LICENSE

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

Makefile

@@ -13,7 +13,7 @@ help:  ## display this help
 
 .PHONY: run
 run: build ## run application
-	@LOG_LEVEL=debug PURGE_METRICS_ON_CRAWL=true BLOCK_SCHEMA_INTROSPECTION=true CACHE_TTL=10 JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ HEALTHCHECK_GRAPHQL_URL=https://hasura8.lan/v1/graphql MONITORING_PORT=8222 PORT_GRAPHQL=8111 ./graphql-proxy
+	@LOG_LEVEL=debug PURGE_METRICS_ON_CRAWL=true BLOCK_SCHEMA_INTROSPECTION=true CACHE_TTL=10 JWT_ROLE_RATE_LIMIT=false JWT_ROLE_CLAIM_PATH="Hasura.x-hasura-default-role" JWT_USER_CLAIM_PATH="Hasura.x-hasura-user-id" HOST_GRAPHQL=https://hasura8.lan/ HEALTHCHECK_GRAPHQL_URL=https://hasura8.lan/v1/graphql PORT_GRAPHQL=8111 ./graphql-proxy
 
 .PHONY: build
 build: ## build the binary

README.md

@@ -17,12 +17,7 @@ This project is in active use by [telegram-bot.app](https://telegram-bot.app), a
   - [Tracing](#tracing)
   - [Speed](#speed)
     - [Caching](#caching)
-    - [Memory-Aware Caching](#memory-aware-caching)
     - [Read-only endpoint](#read-only-endpoint)
-  - [Resilience](#resilience)
-    - [Circuit Breaker Pattern](#circuit-breaker-pattern)
-    - [Enhanced HTTP Client](#enhanced-http-client)
-    - [GraphQL Parsing Optimizations](#graphql-parsing-optimizations)
   - [Maintenance](#maintenance)
     - [Hasura event cleaner](#hasura-event-cleaner)
   - [Security](#security)
@@ -46,7 +41,6 @@ I wanted to monitor the queries and responses of our graphql endpoint. Still, we
 
 You should always try to stick to the latest and greatest version of the graphql-proxy to ensure that it's as much bug-free as possible. Following list will be kept to the maximum of five "most important" bugs and enhancements included in the latest versions.
 
-* **19/09/2025 - 0.26.x** - Major security enhancements: Fixed SQL injection vulnerability in event cleaner, added path traversal protection, implemented optional API authentication, enhanced log sanitization to prevent sensitive data exposure, and consolidated buffer pool implementations for better performance.
 * **06/12/2024 - 0.25.12** - Fixes the bug where deeply nested introspection queries were blocked despite of being present on the whitelist. GraphQL proxy will now inspect the queries in depth to find any possible nested introspections.
 
 * **20/08/2024 - 0.23.21+** - Fixes the bug when timeouts were not respected on proxy-graphql line. Affected versions before that were timeouting after 30 seconds which was set as default ( thanks to Jurica Železnjak for reporting ). It also provides a temporary fix for running within kubernetes deployment, when graphql server ( for example - hasura ) took more time to start than the proxy, causing avalanche of errors with "can't proxy the request".
@@ -59,12 +53,10 @@ You can find the example of the Kubernetes manifest in the [example standalone d
 
 #### Note on websocket support
 
-**Native WebSocket Support Available!** Starting with version 0.27.0, the proxy includes native WebSocket support for GraphQL subscriptions. Enable it by setting `WEBSOCKET_ENABLE=true`.
-
-For backward compatibility or if you prefer routing WebSockets directly to your backend, you can use the Traefik configuration below:
+Proxy in its current version 0.23.3 does not support websockets. If you need to proxy the websocket requests - you can use following trick whilst setting up the proxy. As I'm a big fan of Traefik - there's an example which works with the mentioned above combined deployment.
 
 <details>
-  <summary>Click to show Traefik Ingress Route example for direct WebSocket routing.</summary>
+  <summary>Click to show working Traefik Ingress Route example.</summary>
 
 ```yaml
 apiVersion: traefik.containo.us/v1alpha1
@@ -96,12 +88,13 @@ spec:
           namespace: default
 ```
 
+In this case, both proxy and websockets will be available under the `/v1/graphql` path, and the websocket connection will be proxied directly to the hasura service, bypassing the proxy.
+
 </details>
 
 ### Endpoints
 
 * `:8080/*` - the graphql passthrough endpoint
-* `:8080/admin` - the admin dashboard (if enabled)
 * `:9393/metrics` - the prometheus metrics endpoint
 * `:8080/healthz` - the healthcheck endpoint
 * `:8080/livez` - the liveness probe endpoint
@@ -116,16 +109,8 @@ spec:
 | monitor    | Extracting the query name and type and adding it as a label to metrics|
 | monitor    | Calculating the query duration and adding it to the metrics           |
 | monitor    | OpenTelemetry tracing support with configurable endpoint              |
-| monitor    | Real-time admin dashboard with live metrics                           |
-| speed      | Request coalescing to deduplicate concurrent identical queries        |
 | speed      | Caching the queries, together with per-query cache and TTL            |
 | speed      | Support for READ ONLY graphql endpoint                                |
-| speed      | Memory-aware caching with compression and eviction                    |
-| speed      | Native WebSocket support for GraphQL subscriptions                    |
-| resilience | Circuit breaker pattern for fault tolerance                           |
-| resilience | Retry budget to prevent retry storms                                  |
-| resilience | Optimized HTTP client with granular timeout controls                  |
-| resilience | Structured error responses with retry recommendations                 |
 | security   | Blocking schema introspection                                         |
 | security   | Rate limiting queries based on user role                              |
 | security   | Blocking mutations in read-only mode                                  |
@@ -153,31 +138,10 @@ You can still use the non-prefixed environment variables in the spirit of the ba
 | `ROLE_RATE_LIMIT`         | Enable request rate limiting based on role| `false`                   |
 | `ENABLE_GLOBAL_CACHE`     | Enable the cache                        | `false`                    |
 | `CACHE_TTL`               | The cache TTL                           | `60`                       |
-| `CACHE_MAX_MEMORY_SIZE`   | Maximum memory size for cache in MB     | `100`                      |
-| `CACHE_MAX_ENTRIES`       | Maximum number of entries in cache      | `10000`                    |
-| `CACHE_USE_LRU`           | Use LRU eviction algorithm (see [Cache Eviction](#cache-eviction-algorithms)) | `false`    |
-| `CACHE_PER_USER_DISABLED` | **⚠️ SECURITY**: Disable per-user cache isolation | `false` (**DO NOT** set to `true` in multi-user apps) |
 | `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`                        |
-| `ENABLE_CIRCUIT_BREAKER`  | Enable circuit breaker pattern          | `false`                    |
-| `CIRCUIT_MAX_FAILURES`    | Consecutive failures before circuit trips | `10`                     |
-| `CIRCUIT_FAILURE_RATIO`   | Failure ratio threshold (0.0-1.0)       | `0.5`                      |
-| `CIRCUIT_SAMPLE_SIZE`     | Min requests for ratio calculation      | `100`                      |
-| `CIRCUIT_TIMEOUT_SECONDS` | Seconds circuit stays open              | `60`                       |
-| `CIRCUIT_MAX_HALF_OPEN_REQUESTS` | Max requests in half-open state  | `5`                        |
-| `CIRCUIT_RETURN_CACHED_ON_OPEN` | Return cached responses when open | `true`                     |
-| `CIRCUIT_TRIP_ON_TIMEOUTS` | Trip circuit breaker on timeouts       | `true`                     |
-| `CIRCUIT_TRIP_ON_5XX`     | Trip circuit breaker on 5XX responses   | `true`                     |
-| `CIRCUIT_TRIP_ON_4XX`     | Trip circuit breaker on 4XX responses (except 429) | `false`        |
-| `CIRCUIT_BACKOFF_MULTIPLIER` | Exponential backoff multiplier (e.g., 1.5) | `1.0`                 |
-| `CIRCUIT_MAX_BACKOFF_TIMEOUT` | Max timeout in seconds for backoff | `300`                      |
-| `CLIENT_READ_TIMEOUT`     | HTTP client read timeout in seconds     | ``                         |
-| `CLIENT_WRITE_TIMEOUT`    | HTTP client write timeout in seconds    | ``                         |
-| `CLIENT_MAX_IDLE_CONN_DURATION` | Max idle connection duration in seconds | `300`                |
-| `MAX_CONNS_PER_HOST`      | Maximum connections per host            | `1024`                     |
-| `CLIENT_DISABLE_TLS_VERIFY` | Disable TLS verification              | `false`                    |
 | `LOG_LEVEL`               | The log level                           | `info`                     |
 | `BLOCK_SCHEMA_INTROSPECTION`| Blocks the schema introspection       | `false`                    |
 | `ALLOWED_INTROSPECTION`  | Allow only certain queries in introspection | ``                  |
@@ -186,7 +150,6 @@ You can still use the non-prefixed environment variables in the spirit of the ba
 | `ALLOWED_URLS`              | Allow access only to certain URLs       | `/v1/graphql,/v1/version`  |
 | `ENABLE_API`              | Enable the monitoring API               | `false`                    |
 | `API_PORT`                | The port to expose the monitoring API   | `9090`                     |
-| `ADMIN_API_KEY`           | API key for admin endpoint authentication (optional) | ``                |
 | `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`                      |
@@ -196,15 +159,6 @@ You can still use the non-prefixed environment variables in the spirit of the ba
 | `HASURA_EVENT_METADATA_DB` | URL to the hasura metadata database    | `postgresql://localhost:5432/hasura` |
 | `ENABLE_TRACE`            | Enable OpenTelemetry tracing           | `false`                    |
 | `TRACE_ENDPOINT`          | OpenTelemetry collector endpoint       | `localhost:4317`           |
-| `RETRY_BUDGET_ENABLE`     | Enable retry budget mechanism          | `true`                     |
-| `RETRY_BUDGET_TOKENS_PER_SEC` | Retry tokens generated per second  | `10.0`                     |
-| `RETRY_BUDGET_MAX_TOKENS` | Maximum retry tokens allowed           | `100`                      |
-| `REQUEST_COALESCING_ENABLE` | Enable request deduplication         | `true`                     |
-| `WEBSOCKET_ENABLE`        | Enable WebSocket support for subscriptions | `false`                |
-| `WEBSOCKET_PING_INTERVAL` | WebSocket ping interval in seconds     | `30`                       |
-| `WEBSOCKET_PONG_TIMEOUT`  | WebSocket pong timeout in seconds      | `60`                       |
-| `WEBSOCKET_MAX_MESSAGE_SIZE` | Max WebSocket message size in bytes | `524288` (512KB)           |
-| `ADMIN_DASHBOARD_ENABLE`  | Enable admin dashboard UI              | `true`                     |
 
 ### Tracing
 
@@ -226,163 +180,11 @@ The proxy will extract the trace context from the header and create child spans
 
 ### Speed
 
-#### Request Coalescing
-
-Request coalescing (also known as request deduplication) is a powerful optimization that reduces backend load by combining multiple concurrent identical requests into a single backend call. This feature is enabled by default via `REQUEST_COALESCING_ENABLE=true`.
-
-**How it works:**
-- When multiple clients send identical GraphQL queries simultaneously, only one request is forwarded to the backend
-- All other concurrent identical requests wait for the first request to complete
-- Once the response is received, it's shared with all waiting clients
-- This can reduce backend load by 50-80% in high-traffic scenarios with repeated queries
-
-**Benefits:**
-- Dramatically reduces backend load during traffic spikes
-- Prevents "thundering herd" problems when cache expires
-- Improves response times for coalesced requests (they don't need to wait for backend processing)
-- Zero additional latency for the primary request
-
-**Monitoring:**
-The admin dashboard (`/admin`) provides real-time statistics:
-- Total requests vs. primary requests
-- Number of coalesced requests
-- Backend savings percentage
-
-**Configuration:**
-```bash
-# Enable request coalescing (default: true)
-GMP_REQUEST_COALESCING_ENABLE=true
-```
-
-**Use Cases:**
-- High-traffic applications with popular queries
-- Applications with many concurrent users
-- APIs with expensive backend operations
-- Mobile/web apps where users often perform the same actions simultaneously
-
-#### Retry Budget
-
-The retry budget prevents retry storms and cascading failures by limiting the rate at which retries can occur. This is a critical resilience feature enabled by default.
-
-**How it works:**
-- Uses a token bucket algorithm: tokens are generated at a fixed rate
-- Each retry attempt consumes one token
-- When tokens are exhausted, retries are denied until tokens are refilled
-- Automatic refill ensures the system can recover naturally
-
-**Benefits:**
-- Prevents retry storms that can overwhelm recovering backends
-- Reduces cascading failures across services
-- Maintains predictable load during outages
-- Allows graceful degradation instead of complete failure
-
-**Configuration:**
-```bash
-# Enable retry budget (default: true)
-GMP_RETRY_BUDGET_ENABLE=true
-
-# Tokens generated per second (default: 10)
-GMP_RETRY_BUDGET_TOKENS_PER_SEC=10.0
-
-# Maximum tokens that can accumulate (default: 100)
-GMP_RETRY_BUDGET_MAX_TOKENS=100
-```
-
-**Production Recommendations:**
-- **High traffic (1000+ req/s)**: Set `TOKENS_PER_SEC=50`, `MAX_TOKENS=500`
-- **Medium traffic (100-1000 req/s)**: Use defaults (10 tokens/s, 100 max)
-- **Low traffic (<100 req/s)**: Set `TOKENS_PER_SEC=5`, `MAX_TOKENS=50`
-
-**Monitoring:**
-The admin dashboard shows:
-- Current available tokens
-- Total retry attempts
-- Denied retries
-- Denial rate percentage
-
-#### WebSocket Support
-
-Native WebSocket support enables GraphQL subscriptions and real-time features. Enable via `WEBSOCKET_ENABLE=true`.
-
-**Features:**
-- Bidirectional proxying between client and backend
-- Automatic ping/pong keep-alive
-- Configurable message size limits
-- Connection statistics and monitoring
-- Graceful connection handling
-
-**Configuration:**
-```bash
-# Enable WebSocket support
-GMP_WEBSOCKET_ENABLE=true
-
-# Ping interval (seconds)
-GMP_WEBSOCKET_PING_INTERVAL=30
-
-# Pong timeout (seconds)
-GMP_WEBSOCKET_PONG_TIMEOUT=60
-
-# Max message size (bytes)
-GMP_WEBSOCKET_MAX_MESSAGE_SIZE=524288  # 512KB
-```
-
-**Example GraphQL Subscription:**
-```graphql
-subscription OnNewMessage {
-  messages {
-    id
-    content
-    createdAt
-  }
-}
-```
-
-**Monitoring:**
-The admin dashboard (`/admin`) provides:
-- Active WebSocket connections
-- Total connections handled
-- Messages sent/received
-- Connection errors
-
 #### 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` 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.
 
-**Important**: The cache key is calculated from the **request body + user context (user ID and role)**. This means:
-- Identical queries with different variables are cached separately
-- **Identical queries from different users are cached separately** (security isolation)
-- **Identical queries with different roles are cached separately** (prevents privilege escalation)
-- This ensures correct caching behavior and prevents data leakage between users
-
-**🔒 Security Update (v0.27.0+)**: Cache keys now include user context by default to prevent security vulnerabilities where users could see each other's cached data. This is enabled by default and should NOT be disabled in multi-user applications.
-
-Example:
-```graphql
-# These requests will have DIFFERENT cache keys:
-
-# Different variables
-query GetUser($id: ID!) { user(id: $id) { name } }
-variables: { "id": "123" }  // Cache key: MD5(body + user:alice + role:user)
-
-query GetUser($id: ID!) { user(id: $id) { name } }
-variables: { "id": "456" }  // Cache key: MD5(body + user:alice + role:user)
-
-# Different users (SECURITY: prevents data leakage)
-query GetMyProfile { me { email } }
-Authorization: Bearer token_for_alice  // Cache key: MD5(body + user:alice + role:user)
-
-query GetMyProfile { me { email } }
-Authorization: Bearer token_for_bob    // Cache key: MD5(body + user:bob + role:user)
-
-# Different roles (SECURITY: prevents privilege escalation)
-query GetData { data { value } }
-Authorization: Bearer token_admin  // Cache key: MD5(body + user:alice + role:admin)
-
-query GetData { data { value } }
-Authorization: Bearer token_user   // Cache key: MD5(body + user:alice + role:user)
-```
-
 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.
 
@@ -399,366 +201,15 @@ query MyProducts @cached(refresh: true) {
 }
 ```
 
-#### Memory-Aware Caching
-
-Starting with version `0.26.0`, the memory cache implementation has been enhanced with memory-aware features to prevent out-of-memory situations:
-
-- **Memory limits**: Set maximum memory usage via `CACHE_MAX_MEMORY_SIZE` (default: 100MB)
-- **Entry limits**: Set maximum number of entries via `CACHE_MAX_ENTRIES` (default: 10,000)
-- **Smart eviction**: When limits are reached, the cache will automatically evict the least recently used entries
-- **Compression**: Large cache entries are automatically compressed to reduce memory footprint
-- **Memory monitoring**: Memory usage is tracked and reported in metrics
-
-Example configurations:
-
-*Basic memory-aware caching:*
-```bash
-GMP_ENABLE_GLOBAL_CACHE=true
-GMP_CACHE_TTL=60
-GMP_CACHE_MAX_MEMORY_SIZE=100
-GMP_CACHE_MAX_ENTRIES=10000
-```
-
-*High-performance caching for large responses:*
-```bash
-GMP_ENABLE_GLOBAL_CACHE=true
-GMP_CACHE_TTL=300
-GMP_CACHE_MAX_MEMORY_SIZE=500
-GMP_CACHE_MAX_ENTRIES=5000
-```
-
-*Resource-constrained environment:*
-```bash
-GMP_ENABLE_GLOBAL_CACHE=true
-GMP_CACHE_TTL=120
-GMP_CACHE_MAX_MEMORY_SIZE=50
-GMP_CACHE_MAX_ENTRIES=1000
-```
-
-These features ensure the cache runs efficiently even under high load and with large response payloads. The memory-aware cache prevents memory leaks and resource exhaustion while maintaining performance benefits.
-
 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.
 
-#### Cache Eviction Algorithms
-
-The proxy supports two cache eviction strategies:
-
-**Standard (default):** Uses Go's `sync.Map` with approximate eviction. When memory limits are reached, entries are evicted based on iteration order (pseudo-random). This is memory-efficient and has excellent concurrent read performance.
-
-**LRU (Least Recently Used):** Uses a proper LRU algorithm with a linked list to track access order. When limits are reached, the least recently accessed entries are evicted first. Enable with `CACHE_USE_LRU=true`.
-
-| Feature | Standard | LRU |
-|---------|----------|-----|
-| Eviction order | Pseudo-random | Least recently used |
-| Read performance | Excellent | Good |
-| Memory tracking | Approximate | Precise |
-| Best for | High read throughput | Cache hit optimization |
-
-*LRU cache configuration:*
-```bash
-GMP_ENABLE_GLOBAL_CACHE=true
-GMP_CACHE_TTL=300
-GMP_CACHE_USE_LRU=true
-GMP_CACHE_MAX_MEMORY_SIZE=200
-GMP_CACHE_MAX_ENTRIES=5000
-```
-
-Use LRU when cache hit rate is critical and you want to ensure frequently accessed data stays cached. Use Standard (default) for maximum read throughput with less memory overhead.
-
 #### 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).
 
-**Important:** When using a read-only Hasura instance connected to a PostgreSQL read replica, you **must** disable event trigger processing on that instance by setting `HASURA_GRAPHQL_EVENTS_FETCH_INTERVAL=0` in the read-only Hasura container environment variables. This prevents the read-only instance from attempting to process event triggers (which require write access to event log tables), avoiding "cannot set transaction read-write mode during recovery" errors.
-
-### Resilience
-
-#### Circuit Breaker Pattern
-
-The proxy implements an advanced circuit breaker pattern to prevent cascading failures when backend services are unstable. When enabled via `ENABLE_CIRCUIT_BREAKER=true`, the proxy monitors for failures and automatically trips the circuit based on configurable thresholds.
-
-Key features:
-- **Dual tripping strategies**: Trip on consecutive failures OR failure ratio
-- **Automatic recovery**: The circuit breaker will automatically attempt recovery after a timeout period
-- **Health monitoring endpoint**: Check circuit breaker status via `/api/circuit-breaker/health`
-- **Configurable thresholds**: Set failure thresholds, timeouts, and recovery behavior
-- **Fallback mechanism**: Can serve cached responses when the circuit is open
-- **Selective error filtering**: Configure which HTTP status codes trigger failures
-- **Exponential backoff**: Optional progressive timeout increases for repeated failures
-
-##### Production-Ready Configuration for High Traffic
-
-For high-traffic production environments, use these recommended settings:
-
-```bash
-# Basic circuit breaker configuration
-GMP_ENABLE_CIRCUIT_BREAKER=true
-GMP_CIRCUIT_MAX_FAILURES=10           # Tolerant of transient failures
-GMP_CIRCUIT_FAILURE_RATIO=0.5         # Trip at 50% failure rate
-GMP_CIRCUIT_SAMPLE_SIZE=100           # Statistically significant sample
-GMP_CIRCUIT_TIMEOUT_SECONDS=60        # 1 minute recovery window
-GMP_CIRCUIT_MAX_HALF_OPEN_REQUESTS=5  # More probe requests for validation
-
-# Caching fallback
-GMP_CIRCUIT_RETURN_CACHED_ON_OPEN=true
-
-# Error type configuration
-GMP_CIRCUIT_TRIP_ON_TIMEOUTS=true
-GMP_CIRCUIT_TRIP_ON_5XX=true
-GMP_CIRCUIT_TRIP_ON_4XX=false         # 4xx are usually client errors
-
-# Backoff configuration (optional)
-GMP_CIRCUIT_BACKOFF_MULTIPLIER=1.0    # No backoff by default
-GMP_CIRCUIT_MAX_BACKOFF_TIMEOUT=300   # 5 minutes maximum
-```
-
-##### All Circuit Breaker Configuration Options
-
-- `ENABLE_CIRCUIT_BREAKER`: Enable the circuit breaker pattern (default: `false`)
-- `CIRCUIT_MAX_FAILURES`: Consecutive failures before circuit trips (default: `10`)
-- `CIRCUIT_FAILURE_RATIO`: Failure ratio threshold 0.0-1.0 (default: `0.5`)
-- `CIRCUIT_SAMPLE_SIZE`: Minimum requests for ratio calculation (default: `100`)
-- `CIRCUIT_TIMEOUT_SECONDS`: Seconds circuit stays open (default: `60`)
-- `CIRCUIT_MAX_HALF_OPEN_REQUESTS`: Max requests in half-open state (default: `5`)
-- `CIRCUIT_RETURN_CACHED_ON_OPEN`: Return cached responses when open (default: `true`)
-- `CIRCUIT_TRIP_ON_TIMEOUTS`: Count timeouts as failures (default: `true`)
-- `CIRCUIT_TRIP_ON_5XX`: Count 5XX responses as failures (default: `true`)
-- `CIRCUIT_TRIP_ON_4XX`: Count 4XX responses as failures, except 429 (default: `false`)
-- `CIRCUIT_BACKOFF_MULTIPLIER`: Exponential backoff multiplier, e.g., 1.5 (default: `1.0`)
-- `CIRCUIT_MAX_BACKOFF_TIMEOUT`: Maximum timeout in seconds for backoff (default: `300`)
-
-Example configurations:
-
-*Minimal circuit breaker configuration:*
-```bash
-GMP_ENABLE_CIRCUIT_BREAKER=true
-GMP_CIRCUIT_MAX_FAILURES=5
-GMP_CIRCUIT_TIMEOUT_SECONDS=30
-```
-
-*Production-ready circuit breaker with fallback:*
-```bash
-GMP_ENABLE_CIRCUIT_BREAKER=true
-GMP_CIRCUIT_MAX_FAILURES=3
-GMP_CIRCUIT_TIMEOUT_SECONDS=15
-GMP_CIRCUIT_MAX_HALF_OPEN_REQUESTS=1
-GMP_CIRCUIT_RETURN_CACHED_ON_OPEN=true
-GMP_CIRCUIT_TRIP_ON_TIMEOUTS=true
-GMP_CIRCUIT_TRIP_ON_5XX=true
-```
-
-*Aggressive circuit breaking for critical systems:*
-```bash
-GMP_ENABLE_CIRCUIT_BREAKER=true
-GMP_CIRCUIT_MAX_FAILURES=1
-GMP_CIRCUIT_TIMEOUT_SECONDS=60
-GMP_CIRCUIT_MAX_HALF_OPEN_REQUESTS=1
-GMP_CIRCUIT_RETURN_CACHED_ON_OPEN=true
-GMP_CIRCUIT_TRIP_ON_TIMEOUTS=true
-GMP_CIRCUIT_TRIP_ON_5XX=true
-```
-
-#### Enhanced HTTP Client
-
-The proxy includes an optimized HTTP client with granular controls for timeouts, connection pooling, and TLS verification. This helps improve performance and reliability when communicating with backend GraphQL servers.
-
-Configuration:
-- `CLIENT_READ_TIMEOUT`: HTTP client read timeout in seconds
-- `CLIENT_WRITE_TIMEOUT`: HTTP client write timeout in seconds
-- `CLIENT_MAX_IDLE_CONN_DURATION`: Maximum duration to keep idle connections open (default: `300` seconds)
-- `MAX_CONNS_PER_HOST`: Maximum number of connections per host (default: `1024`)
-- `CLIENT_DISABLE_TLS_VERIFY`: Disable TLS certificate verification (default: `false`)
-#### GraphQL Parsing Optimizations
-
-Version 0.26.0 includes several optimizations to GraphQL query parsing and execution:
-
-- **Query parsing cache**: Identical queries are parsed only once, improving performance for repeated queries
-- **Efficient mutation detection**: Optimized logic for identifying and routing mutations
-- **Memory efficiency**: Improved memory management during GraphQL operations
-- **Enhanced introspection handling**: Better security for introspection queries
-
-These optimizations are applied automatically with no configuration required, resulting in improved performance and reduced resource usage, especially for high-traffic deployments.
-
-
-
-Example configurations:
-
-*High-performance client for low-latency environments:*
-```bash
-GMP_CLIENT_READ_TIMEOUT=1
-GMP_CLIENT_WRITE_TIMEOUT=1
-GMP_CLIENT_MAX_IDLE_CONN_DURATION=60
-GMP_MAX_CONNS_PER_HOST=2048
-```
-
-*Client for high-reliability environments:*
-```bash
-GMP_CLIENT_READ_TIMEOUT=5
-GMP_CLIENT_WRITE_TIMEOUT=5
-GMP_CLIENT_MAX_IDLE_CONN_DURATION=120
-GMP_MAX_CONNS_PER_HOST=1024
-```
-
-#### Connection Resilience and Startup Management
-
-The proxy includes comprehensive connection resilience features to handle backend GraphQL endpoint startup delays and connection recovery scenarios.
-
-##### Startup Readiness Probe
-
-The proxy can wait for the GraphQL backend to become available before accepting traffic, preventing failed requests during backend startup:
-
-```bash
-# Wait up to 5 minutes for backend to be ready (default: 300 seconds)
-GMP_BACKEND_STARTUP_TIMEOUT=300
-```
-
-When enabled, the proxy will:
-- Perform periodic health checks against the GraphQL backend during startup
-- Use exponential backoff with jitter for health check retries
-- Log startup progress and backend readiness status
-- Start accepting traffic only after backend is confirmed healthy
-- Continue startup if backend doesn't respond within the timeout (with warnings)
-
-##### Backend Health Monitoring
-
-Continuous health monitoring runs in the background to detect backend availability:
-
-- **Health Check Interval**: 5 seconds
-- **Health Check Method**: Minimal GraphQL introspection query (`{__typename}`)
-- **Failure Tracking**: Consecutive failure counting with automatic recovery detection
-- **Integration**: Works with circuit breaker and retry mechanisms
-
-##### Intelligent Retry with Connection Awareness
-
-Enhanced retry mechanism that adapts based on backend health and error types:
-
-**Normal Operation (Healthy Backend)**:
-- 7 retry attempts
-- Initial delay: 500ms
-- Maximum delay: 10 seconds
-- Exponential backoff
-
-**Degraded Operation (Unhealthy Backend)**:
-- 10 retry attempts
-- Initial delay: 2 seconds
-- Maximum delay: 30 seconds
-- Longer delays to account for backend recovery time
-
-**Error Classification**:
-- Connection errors (connection refused, reset, etc.): Retryable
-- Timeout errors: Limited retries to prevent cascade failures
-- 4xx client errors: Generally not retryable (except 429, 503)
-- 5xx server errors: Retryable with backoff
-
-##### Connection Pool with Auto-Recovery
-
-Advanced connection pool management with automatic health monitoring and recovery:
-
-**Keep-Alive Mechanism**:
-- Interval: 15 seconds
-- Lightweight GraphQL queries to maintain connection health
-- Automatic failure detection and recovery
-
-**Connection Recovery**:
-- Recovery check interval: 60 seconds
-- Automatic connection pool reset after 5+ consecutive failures
-- Coordinated with backend health status
-
-**Connection Statistics Tracking**:
-- Active connection count
-- Total connection attempts
-- Failure rate monitoring
-- Last recovery attempt timestamp
-
-##### Graceful Degradation
-
-When the backend is unavailable, the proxy provides graceful degradation:
-
-**Cache Fallback** (if circuit breaker configured):
-- Serve cached responses when backend is unavailable
-- Automatic cache hit metrics tracking
-
-**Informative Error Responses**:
-- Standard GraphQL error format with helpful extensions
-- Includes retry recommendations and timeout information
-- Maintains API contract even during failures
-
-**Example Error Response**:
-```json
-{
-  "errors": [{
-    "message": "GraphQL backend is temporarily unavailable",
-    "extensions": {
-      "code": "SERVICE_UNAVAILABLE",
-      "retryable": true,
-      "retry_after": 60
-    }
-  }],
-  "data": null
-}
-```
-
-##### Monitoring and Observability
-
-Connection resilience provides extensive monitoring through API endpoints:
-
-**Backend Health Endpoint**: `/api/backend/health`
-```json
-{
-  "status": "healthy",
-  "backend_url": "http://graphql-backend:4000",
-  "last_health_check": "2024-01-15T10:30:00Z",
-  "consecutive_failures": 0,
-  "check_interval": "5s"
-}
-```
-
-**Connection Pool Health Endpoint**: `/api/connection-pool/health`
-```json
-{
-  "status": "healthy",
-  "active_connections": 12,
-  "total_connections": 1547,
-  "connection_failures": 2,
-  "last_recovery_attempt": "2024-01-15T09:15:00Z",
-  "cleanup_interval": "30s",
-  "keepalive_interval": "15s",
-  "recovery_check_interval": "60s"
-}
-```
-
-##### Production Configuration Example
-
-For high-availability production environments:
-
-```bash
-# Backend startup management
-GMP_BACKEND_STARTUP_TIMEOUT=600  # 10 minutes for complex backends
-
-# Enhanced connection pool
-GMP_MAX_CONNS_PER_HOST=2048
-GMP_CLIENT_MAX_IDLE_CONN_DURATION=300
-
-# Circuit breaker for graceful degradation
-GMP_ENABLE_CIRCUIT_BREAKER=true
-GMP_CIRCUIT_RETURN_CACHED_ON_OPEN=true
-GMP_CIRCUIT_MAX_FAILURES=5
-GMP_CIRCUIT_TIMEOUT_SECONDS=120
-
-# Caching for fallback responses
-GMP_ENABLE_GLOBAL_CACHE=true
-GMP_CACHE_TTL=300
-```
-
-This configuration provides:
-- Extended startup patience for complex GraphQL backends
-- High connection capacity with efficient pooling
-- Circuit breaker protection with cache fallback
-- 5-minute cache retention for fallback scenarios
-
 ### Maintenance
 
 #### Hasura event cleaner
@@ -772,84 +223,38 @@ Following tables are being cleaned:
 - `hdb_catalog.hdb_cron_event_invocation_logs`
 - `hdb_catalog.hdb_scheduled_event_invocation_logs`
 
-**Important for RO/RW setups:** The `HASURA_EVENT_METADATA_DB` connection string must point to the **read-write primary database** where the `hdb_catalog` schema resides. The cleaner executes DELETE operations which require write permissions. Do not point this to a read-only replica.
-
 
 ### Security
 
-#### Advanced Rate Limiting
+#### Role-based rate limiting
 
-The proxy supports multiple rate limiting strategies to protect your GraphQL endpoint from abuse:
+You can rate limit requests using the `ROLE_RATE_LIMIT` environment variable. If enabled, the proxy will rate limit the requests based on the role claim in the JWT token. You can then provide the JSON file in the following format to specify the limits.
+The default interval is `second`, but you can use other values as well. If you want to disable the rate limiting for a specific role, you can set the `req` to `0`.
 
-##### Role-based Rate Limiting
+Available values:
+`nano`, `micro`, `milli`, `second`, `minute`, `hour`, `day`
 
-Enable rate limiting based on user roles using the `ROLE_RATE_LIMIT` environment variable. The proxy extracts the role from JWT tokens or headers and applies appropriate limits.
+To define path in JWT token where the current user role is present, use the `JWT_ROLE_CLAIM_PATH` environment variable.
 
-**Configuration:**
-- `JWT_ROLE_CLAIM_PATH`: Path to the role claim in JWT token
-- `ROLE_FROM_HEADER`: Header name to extract role from (takes priority over JWT)
-- `ROLE_RATE_LIMIT`: Enable role-based rate limiting (default: `false`)
+You can also set up the `ROLE_FROM_HEADER` environment variable to extract the role from the header instead of the JWT token. This is useful if you want to rate limit the requests for unauthenticated users. It's worth mentioning that `ROLE_FROM_HEADER` takes a priority over the `JWT_ROLE_CLAIM_PATH` environment variable and if its set, the proxy will not try to extract the role from the JWT token.
 
-**Features:**
-- **Dynamic configuration reload**: Rate limit configuration is automatically reloaded periodically without restart
-- **Burst control**: Optional burst limits for handling traffic spikes
-- **Per-endpoint limits**: Different rate limits for specific GraphQL endpoints
-- **IP-based limiting**: Additional rate limiting by client IP address
-
-Available interval values:
-`nano`, `micro`, `milli`, `second`, `minute`, `hour`, `day`, or duration strings like `5s`, `10m`
-
-##### Basic Rate Limit Configuration (`ratelimit.json`)
+*Default/sample configuration:*
 
 ```json
 {
   "ratelimit": {
-    "admin": {
-      "req": 100,
-      "interval": "second"
-    },
-    "guest": {
-      "req": 50,
-      "interval": "minute"
-    },
-    "-": {  // Default/fallback role
-      "req": 100,
-      "interval": "day"
-    }
-  }
-}
-```
-
-##### Production-Ready Rate Limit Configuration for High Traffic
-
-```json
-{
-  "ratelimit": {
-    "admin": {
-      "req": 1000,
-      "interval": "second",
-      "burst": 2000,  // Allow bursts up to 2000 requests
-      "endpoints": ["/v1/graphql", "/v1/relay"]  // Optional endpoint-specific limits
-    },
-    "premium": {
-      "req": 500,
-      "interval": "second",
-      "burst": 1000
-    },
-    "standard": {
-      "req": 100,
-      "interval": "second",
-      "burst": 200
-    },
-    "guest": {
-      "req": 10,
-      "interval": "second",
-      "burst": 20
-    },
-    "-": {  // Default/fallback role - deny by default for security
-      "req": 5,
-      "interval": "second"
-    }
+      "admin": {
+          "req": 100,
+          "interval": "second"
+      },
+      "guest": {
+          "req": 50,
+          "interval": "minute"
+      },
+      "-": {
+          "req": 100,
+          "interval": "day"
+      }
   }
 }
 ```
@@ -877,52 +282,13 @@ If you'd like to keep blocking of the schema introspection on but allow one or m
 
 `ALLOWED_INTROSPECTION="__typename,__type"`
 
-#### Security Best Practices
-
-The GraphQL monitoring proxy implements several security measures to protect your GraphQL endpoints:
-
-1. **Input Validation**: All user inputs are validated and sanitized to prevent injection attacks. File paths are validated to prevent path traversal attacks.
-
-2. **Parameterized Queries**: Database queries use parameterized statements to prevent SQL injection vulnerabilities.
-
-3. **Log Sanitization**: Sensitive data (passwords, tokens, API keys, credit cards, SSNs) are automatically redacted from debug logs to prevent information disclosure.
-
-4. **Optional API Authentication**: Admin endpoints can be protected with API key authentication when needed, while supporting network-level security for internal deployments.
-
-5. **Rate Limiting**: Role-based rate limiting prevents abuse and DDoS attacks.
-
-6. **GraphQL Query Complexity**: The proxy can analyze and limit query complexity to prevent resource exhaustion attacks.
-
-For production deployments, we recommend:
-- Running the proxy in a secure network segment (VPC, Kubernetes cluster)
-- Using TLS for all connections
-- Enabling authentication for admin APIs in less secure environments
-- Implementing proper monitoring and alerting
-- Regularly updating to the latest version for security patches
-
 ### API endpoints
 
-#### Authentication
-
-The admin API endpoints support optional authentication for flexibility in different deployment scenarios:
-
-- **Without Authentication** (default): When `ADMIN_API_KEY` or `GMP_ADMIN_API_KEY` is not set, the API endpoints are accessible without authentication. This is suitable for internal services protected by network segmentation (firewalls, VPCs, Kubernetes network policies, service mesh, etc.).
-
-- **With Authentication**: When `ADMIN_API_KEY` or `GMP_ADMIN_API_KEY` is set to a value, all admin API requests must include the `X-API-Key` header with the matching key. This provides application-level security for deployments in less secure environments.
-
-Example with authentication enabled:
-```bash
-curl -X POST \
-  http://localhost:9090/api/cache-clear \
-  -H 'X-API-Key: your-secret-key-here' \
-  -H 'Content-Type: application/json'
-```
-
 #### Ban or unban the user
 
 Your monitoring system can detect user misbehaving, for example trying to extract / scrap the data. To prevent user from doing so you can use the simple API to ban the user from accessing the application.
 
-To do so - you need to enable the api by setting env variable `ENABLE_API=true` which will expose the API on the port `API_PORT=9090`. When deployed internally, keep it secure by not exposing it outside of your cluster. For additional security, set `ADMIN_API_KEY` to require authentication.
+To do so - you need to enable the api by setting env variable `ENABLE_API=true` which will expose the API on the port `API_PORT=9090`. Nedless to say - keep it secure and don't expose it outside of your cluster.
 
  Then you can use the following endpoints:
 
@@ -934,41 +300,9 @@ To do so - you need to enable the api by setting env variable `ENABLE_API=true`
 * `POST /api/cache-clear` - clear the cache
 * `GET /api/cache-stats` - get the cache statistics ( hits, misses, size )
 
-#### Circuit Breaker Health
+Both endpoints require the `user_id` parameter to be present in the request body and allow you to provide the reason for the ban.
 
-* `GET /api/circuit-breaker/health` - get the circuit breaker health status
-
-The circuit breaker health endpoint returns detailed information about the circuit state:
-- Current state (healthy/recovering/unhealthy)
-- Request counts and failure statistics
-- Current configuration
-
-Example response:
-```json
-{
-  "status": "healthy",
-  "state": "closed",
-  "counts": {
-    "requests": 1000,
-    "total_successes": 950,
-    "total_failures": 50,
-    "consecutive_successes": 10,
-    "consecutive_failures": 0
-  },
-  "configuration": {
-    "max_failures": 10,
-    "failure_ratio": 0.5,
-    "sample_size": 100,
-    "timeout_seconds": 60,
-    "max_half_open_reqs": 5,
-    "backoff_multiplier": 1.0
-  }
-}
-```
-
-Both ban/unban endpoints require the `user_id` and `reason` parameters to be present in the request body.
-
-Example request without authentication (internal deployment):
+Example request:
 
 ```bash
 curl -X POST \
@@ -980,87 +314,8 @@ curl -X POST \
     }'
 ```
 
-Example request with authentication enabled:
-
-```bash
-curl -X POST \
-  http://localhost:9090/api/user-ban \
-  -H 'X-API-Key: your-secret-key-here' \
-  -H 'Content-Type: application/json' \
-  -d '{
-      "user_id": "1337",
-      "reason": "Scraping data"
-    }'
-```
-
 Ban details will be stored in the `banned_users.json` file, which you can mount as a file or configmap to the `/go/src/app/banned_users.json` path ( or use `BANNED_USERS_FILE` environment variable to specify the path to the file). The file operation is important if you have multiple instances of the proxy running, as it will allow you to ban the user from accessing the application on all instances.
 
-### Admin Dashboard
-
-The admin dashboard provides a real-time, web-based interface for monitoring proxy performance and health. Access it at `/admin` or `/admin/dashboard` on the main proxy port (default: `:8080/admin`).
-
-**Features:**
-- **Real-time metrics**: Auto-refreshes every 5 seconds
-- **System health**: Backend GraphQL and Redis connectivity status
-- **Circuit breaker**: Current state, configuration, and statistics
-- **Request coalescing**: Deduplication rate and backend savings
-- **Retry budget**: Available tokens and denial rate
-- **WebSocket**: Active connections and message statistics
-- **Connection pool**: Active connections and health status
-- **Cache statistics**: Hit/miss rates and memory usage
-
-**Configuration:**
-```bash
-# Enable admin dashboard (default: true)
-GMP_ADMIN_DASHBOARD_ENABLE=true
-```
-
-**Security Considerations:**
-- The dashboard is accessible on the main proxy port
-- For production, consider:
-  - Using Kubernetes NetworkPolicies to restrict access
-  - Adding authentication via ingress/service mesh
-  - Disabling the dashboard in production if not needed
-  - Using port-forwarding for administrative access
-
-**Dashboard Sections:**
-
-1. **System Health**
-   - Overall health status (healthy/unhealthy)
-   - Backend GraphQL connectivity
-   - Redis connectivity (if enabled)
-   - Response times for health checks
-
-2. **Key Metrics**
-   - Request coalescing rate (% of backend savings)
-   - Retry budget tokens available
-   - Active WebSocket connections
-   - Active connection pool connections
-
-3. **Circuit Breaker**
-   - Current state (closed/half-open/open)
-   - Configuration (max failures, timeout, etc.)
-   - Recent statistics
-
-4. **Detailed Statistics**
-   - Request coalescing: Total, primary, and coalesced requests with backend savings percentage
-   - Retry budget: Current tokens, max tokens, total attempts, denied retries, and denial rate
-   - Control actions: Reset statistics, clear cache
-
-**API Endpoints:**
-The dashboard fetches data from these API endpoints:
-- `GET /admin/api/health` - System health status
-- `GET /admin/api/circuit-breaker` - Circuit breaker status
-- `GET /admin/api/coalescing` - Request coalescing statistics
-- `GET /admin/api/retry-budget` - Retry budget statistics
-- `GET /admin/api/websocket` - WebSocket connection statistics
-- `GET /admin/api/connections` - Connection pool statistics
-- `POST /admin/api/coalescing/reset` - Reset coalescing stats
-- `POST /admin/api/retry-budget/reset` - Reset retry budget stats
-
-**Screenshot:**
-![Admin Dashboard](static/admin-dashboard.png)
-
 ### General
 
 #### Metrics which matter
@@ -1096,3 +351,5 @@ graphql_proxy_cache_hit{microservice="graphql_proxy",pod="hasura-w-proxy-interna
 graphql_proxy_cache_hit{pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc",microservice="graphql_proxy"} 1
 graphql_proxy_cache_miss{microservice="graphql_proxy",pod="hasura-w-proxy-internal-6b5f4b4bbb-9xwfc"} 23
 ```
+
+.

admin_dashboard.go

@@ -1,987 +0,0 @@
-package main
-
-import (
-	"embed"
-	"encoding/json"
-	"fmt"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	"github.com/gofiber/websocket/v2"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-//go:embed admin/dashboard.html
-var dashboardHTML embed.FS
-
-// AdminDashboard provides monitoring and management interface
-type AdminDashboard struct {
-	logger *libpack_logger.Logger
-}
-
-// NewAdminDashboard creates a new admin dashboard
-func NewAdminDashboard(logger *libpack_logger.Logger) *AdminDashboard {
-	return &AdminDashboard{
-		logger: logger,
-	}
-}
-
-// RegisterRoutes registers dashboard routes
-func (ad *AdminDashboard) RegisterRoutes(app *fiber.App) {
-	// Dashboard UI
-	app.Get("/admin", ad.serveDashboard)
-	app.Get("/admin/dashboard", ad.serveDashboard)
-
-	// API endpoints for dashboard data
-	app.Get("/admin/api/stats", ad.getStats)
-	app.Get("/admin/api/health", ad.getHealth)
-	app.Get("/admin/api/circuit-breaker", ad.getCircuitBreakerStatus)
-	app.Get("/admin/api/cache", ad.getCacheStats)
-	app.Get("/admin/api/connections", ad.getConnectionStats)
-	app.Get("/admin/api/retry-budget", ad.getRetryBudgetStats)
-	app.Get("/admin/api/coalescing", ad.getCoalescingStats)
-	app.Get("/admin/api/websocket", ad.getWebSocketStats)
-
-	// WebSocket endpoint for streaming statistics
-	app.Get("/admin/ws/stats", websocket.New(ad.handleStatsWebSocket))
-
-	// Cluster mode endpoints (when using Redis)
-	app.Get("/admin/api/cluster/stats", ad.getClusterStats)
-	app.Get("/admin/api/cluster/instances", ad.getClusterInstances)
-	app.Get("/admin/api/cluster/debug", ad.getClusterDebug)
-	app.Post("/admin/api/cluster/force-publish", ad.forcePublish)
-
-	// Control endpoints
-	app.Post("/admin/api/cache/clear", ad.clearCache)
-	app.Post("/admin/api/retry-budget/reset", ad.resetRetryBudget)
-	app.Post("/admin/api/coalescing/reset", ad.resetCoalescing)
-
-	if ad.logger != nil {
-		ad.logger.Info(&libpack_logger.LogMessage{
-			Message: "Admin dashboard routes registered",
-			Pairs: map[string]interface{}{
-				"path": "/admin",
-			},
-		})
-	}
-}
-
-// serveDashboard serves the dashboard HTML
-func (ad *AdminDashboard) serveDashboard(c *fiber.Ctx) error {
-	data, err := dashboardHTML.ReadFile("admin/dashboard.html")
-	if err != nil {
-		return c.Status(500).SendString("Failed to load dashboard")
-	}
-
-	c.Set("Content-Type", "text/html; charset=utf-8")
-	return c.Send(data)
-}
-
-// getStats returns overall proxy statistics
-// In cluster mode (when metrics aggregator is available), returns aggregated stats from all instances
-func (ad *AdminDashboard) getStats(c *fiber.Ctx) error {
-	// Check if cluster mode is enabled - if so, return aggregated stats
-	if aggregator := GetMetricsAggregator(); aggregator != nil {
-		metrics, err := aggregator.GetAggregatedMetrics()
-		if err != nil {
-			if ad.logger != nil {
-				ad.logger.Error(&libpack_logger.LogMessage{
-					Message: "Failed to get aggregated metrics, falling back to local stats",
-					Pairs:   map[string]interface{}{"error": err.Error()},
-				})
-			}
-			// Fall through to local stats on error
-		} else {
-			// Return aggregated cluster stats
-			response := map[string]interface{}{
-				"cluster_mode":      true,
-				"total_instances":   metrics.TotalInstances,
-				"healthy_instances": metrics.HealthyInstances,
-				"timestamp":         metrics.LastUpdate.Format(time.RFC3339),
-				"version":           "0.27.0",
-			}
-
-			// Add combined stats from aggregation
-			if metrics.CombinedStats != nil {
-				for k, v := range metrics.CombinedStats {
-					response[k] = v
-				}
-			}
-
-			return c.JSON(response)
-		}
-	}
-
-	// Local instance stats (fallback or non-cluster mode)
-	uptimeSeconds := time.Since(startTime).Seconds()
-	stats := map[string]interface{}{
-		"cluster_mode":   false,
-		"timestamp":      time.Now().Format(time.RFC3339),
-		"uptime_seconds": uptimeSeconds,
-		"uptime_human":   formatDuration(time.Since(startTime)),
-		"version":        "0.27.0", // TODO: Get from build info
-	}
-
-	if cfg != nil && cfg.Monitoring != nil {
-		succeeded := getAdminMetricValue("requests_succesful")
-		failed := getAdminMetricValue("requests_failed")
-		skipped := getAdminMetricValue("requests_skipped")
-		total := succeeded + failed + skipped
-
-		// Request statistics
-		requestStats := map[string]interface{}{
-			"total":     total,
-			"succeeded": succeeded,
-			"failed":    failed,
-			"skipped":   skipped,
-		}
-
-		// Calculate rates and percentages
-		if total > 0 {
-			requestStats["success_rate_pct"] = float64(succeeded) / float64(total) * 100
-			requestStats["failure_rate_pct"] = float64(failed) / float64(total) * 100
-			requestStats["skip_rate_pct"] = float64(skipped) / float64(total) * 100
-		} else {
-			requestStats["success_rate_pct"] = 0.0
-			requestStats["failure_rate_pct"] = 0.0
-			requestStats["skip_rate_pct"] = 0.0
-		}
-
-		// Calculate average requests per second (lifetime)
-		if uptimeSeconds > 0 {
-			requestStats["avg_requests_per_second"] = float64(total) / uptimeSeconds
-		} else {
-			requestStats["avg_requests_per_second"] = 0.0
-		}
-
-		// Get current requests per second (last 1 second)
-		if rpsTracker := GetRPSTracker(); rpsTracker != nil {
-			requestStats["current_requests_per_second"] = rpsTracker.GetCurrentRPS()
-		} else {
-			requestStats["current_requests_per_second"] = 0.0
-		}
-
-		stats["requests"] = requestStats
-
-		// Get cache statistics summary
-		cacheStats := libpack_cache.GetCacheStats()
-		if cacheStats != nil {
-			totalCacheRequests := cacheStats.CacheHits + cacheStats.CacheMisses
-			hitRate := 0.0
-			if totalCacheRequests > 0 {
-				hitRate = float64(cacheStats.CacheHits) / float64(totalCacheRequests) * 100
-			}
-			stats["cache_summary"] = map[string]interface{}{
-				"hits":         cacheStats.CacheHits,
-				"misses":       cacheStats.CacheMisses,
-				"hit_rate_pct": hitRate,
-				"total_cached": cacheStats.CachedQueries,
-			}
-		}
-	}
-
-	return c.JSON(stats)
-}
-
-// formatDuration formats a duration into human-readable format
-func formatDuration(d time.Duration) string {
-	days := int(d.Hours() / 24)
-	hours := int(d.Hours()) % 24
-	minutes := int(d.Minutes()) % 60
-	seconds := int(d.Seconds()) % 60
-
-	if days > 0 {
-		return fmt.Sprintf("%dd %dh %dm %ds", days, hours, minutes, seconds)
-	} else if hours > 0 {
-		return fmt.Sprintf("%dh %dm %ds", hours, minutes, seconds)
-	} else if minutes > 0 {
-		return fmt.Sprintf("%dm %ds", minutes, seconds)
-	}
-	return fmt.Sprintf("%ds", seconds)
-}
-
-// getHealth returns health status
-func (ad *AdminDashboard) getHealth(c *fiber.Ctx) error {
-	healthMgr := GetBackendHealthManager()
-
-	health := map[string]interface{}{
-		"status": "unknown",
-		"backend": map[string]interface{}{
-			"healthy": false,
-		},
-	}
-
-	if healthMgr != nil {
-		isHealthy := healthMgr.IsHealthy()
-		health["backend"] = map[string]interface{}{
-			"healthy":              isHealthy,
-			"consecutive_failures": healthMgr.GetConsecutiveFailures(),
-			"last_check":           healthMgr.GetLastHealthCheck().Format(time.RFC3339),
-		}
-
-		if isHealthy {
-			health["status"] = "healthy"
-		} else {
-			health["status"] = "unhealthy"
-		}
-	}
-
-	return c.JSON(health)
-}
-
-// getCircuitBreakerStatus returns circuit breaker status
-func (ad *AdminDashboard) getCircuitBreakerStatus(c *fiber.Ctx) error {
-	status := map[string]interface{}{
-		"enabled": false,
-		"state":   "unknown",
-	}
-
-	if cfg != nil {
-		status["enabled"] = cfg.CircuitBreaker.Enable
-
-		if cb != nil {
-			cbMutex.RLock()
-			state := cb.State()
-			counts := cb.Counts()
-			cbMutex.RUnlock()
-
-			status["state"] = state.String()
-			status["counts"] = map[string]interface{}{
-				"requests":              counts.Requests,
-				"total_successes":       counts.TotalSuccesses,
-				"total_failures":        counts.TotalFailures,
-				"consecutive_successes": counts.ConsecutiveSuccesses,
-				"consecutive_failures":  counts.ConsecutiveFailures,
-			}
-			status["config"] = map[string]interface{}{
-				"max_failures":           cfg.CircuitBreaker.MaxFailures,
-				"failure_ratio":          cfg.CircuitBreaker.FailureRatio,
-				"timeout":                cfg.CircuitBreaker.Timeout,
-				"max_requests_half_open": cfg.CircuitBreaker.MaxRequestsInHalfOpen,
-				"return_cached_on_open":  cfg.CircuitBreaker.ReturnCachedOnOpen,
-			}
-		}
-	}
-
-	return c.JSON(status)
-}
-
-// getCacheStats returns cache statistics
-// In cluster mode, returns aggregated cache stats from all instances
-func (ad *AdminDashboard) getCacheStats(c *fiber.Ctx) error {
-	// Check if cluster mode is enabled - if so, return aggregated cache stats
-	if aggregator := GetMetricsAggregator(); aggregator != nil {
-		metrics, err := aggregator.GetAggregatedMetrics()
-		if err != nil {
-			if ad.logger != nil {
-				ad.logger.Error(&libpack_logger.LogMessage{
-					Message: "Failed to get aggregated cache metrics, falling back to local stats",
-					Pairs:   map[string]interface{}{"error": err.Error()},
-				})
-			}
-			// Fall through to local stats on error
-		} else {
-			// Build aggregated cache stats from combined stats
-			response := map[string]interface{}{
-				"cluster_mode":    true,
-				"total_instances": metrics.TotalInstances,
-			}
-
-			// Add cache config from local config
-			if cfg != nil {
-				response["enabled"] = cfg.Cache.CacheEnable
-				response["redis_enabled"] = cfg.Cache.CacheRedisEnable
-				response["ttl_seconds"] = cfg.Cache.CacheTTL
-				response["max_memory_mb"] = cfg.Cache.CacheMaxMemorySize
-				response["max_entries"] = cfg.Cache.CacheMaxEntries
-			}
-
-			// Extract aggregated cache stats from combined stats
-			if metrics.CombinedStats != nil {
-				if cacheHits, ok := metrics.CombinedStats["cache_hits"]; ok {
-					response["cache_hits"] = cacheHits
-				}
-				if cacheMisses, ok := metrics.CombinedStats["cache_misses"]; ok {
-					response["cache_misses"] = cacheMisses
-				}
-				if cachedQueries, ok := metrics.CombinedStats["cached_queries"]; ok {
-					response["cached_queries"] = cachedQueries
-				}
-				if hitRate, ok := metrics.CombinedStats["cache_hit_rate_pct"]; ok {
-					response["hit_rate_pct"] = hitRate
-				}
-				if memoryMB, ok := metrics.CombinedStats["memory_usage_mb"]; ok {
-					response["memory_usage_mb"] = memoryMB
-				}
-			}
-
-			return c.JSON(response)
-		}
-	}
-
-	// Local instance stats (fallback or non-cluster mode)
-	stats := map[string]interface{}{
-		"cluster_mode": false,
-		"enabled":      false,
-	}
-
-	if cfg != nil {
-		stats["enabled"] = cfg.Cache.CacheEnable
-		stats["redis_enabled"] = cfg.Cache.CacheRedisEnable
-		stats["ttl_seconds"] = cfg.Cache.CacheTTL
-		stats["max_memory_mb"] = cfg.Cache.CacheMaxMemorySize
-		stats["max_entries"] = cfg.Cache.CacheMaxEntries
-
-		// Get runtime cache statistics
-		cacheStats := libpack_cache.GetCacheStats()
-		if cacheStats != nil {
-			stats["cached_queries"] = cacheStats.CachedQueries
-			stats["cache_hits"] = cacheStats.CacheHits
-			stats["cache_misses"] = cacheStats.CacheMisses
-
-			// Calculate hit rate
-			totalRequests := cacheStats.CacheHits + cacheStats.CacheMisses
-			hitRate := 0.0
-			if totalRequests > 0 {
-				hitRate = float64(cacheStats.CacheHits) / float64(totalRequests) * 100
-			}
-			stats["hit_rate_pct"] = hitRate
-
-			// Get memory usage only for in-memory cache
-			if cfg.Cache.CacheEnable && !cfg.Cache.CacheRedisEnable {
-				memoryUsage := libpack_cache.GetCacheMemoryUsage()
-				maxMemory := libpack_cache.GetCacheMaxMemorySize()
-				stats["memory_usage_bytes"] = memoryUsage
-				stats["memory_usage_mb"] = float64(memoryUsage) / (1024 * 1024)
-
-				// Calculate memory usage percentage
-				memoryUsagePct := 0.0
-				if maxMemory > 0 {
-					memoryUsagePct = float64(memoryUsage) / float64(maxMemory) * 100
-				}
-				stats["memory_usage_pct"] = memoryUsagePct
-			} else {
-				// For Redis cache, memory tracking not available per instance
-				stats["memory_usage_mb"] = -1 // Sentinel value for "not applicable"
-				stats["memory_usage_pct"] = -1
-			}
-		}
-	}
-
-	return c.JSON(stats)
-}
-
-// getConnectionStats returns connection pool statistics
-func (ad *AdminDashboard) getConnectionStats(c *fiber.Ctx) error {
-	poolMgr := GetConnectionPoolManager()
-
-	stats := map[string]interface{}{
-		"available": false,
-	}
-
-	if poolMgr != nil {
-		stats = poolMgr.GetConnectionStats()
-		stats["available"] = true
-	}
-
-	return c.JSON(stats)
-}
-
-// getRetryBudgetStats returns retry budget statistics
-func (ad *AdminDashboard) getRetryBudgetStats(c *fiber.Ctx) error {
-	rb := GetRetryBudget()
-
-	if rb == nil {
-		return c.JSON(map[string]interface{}{
-			"enabled": false,
-		})
-	}
-
-	return c.JSON(rb.GetStats())
-}
-
-// getCoalescingStats returns request coalescing statistics
-func (ad *AdminDashboard) getCoalescingStats(c *fiber.Ctx) error {
-	rc := GetRequestCoalescer()
-
-	if rc == nil {
-		return c.JSON(map[string]interface{}{
-			"enabled": false,
-		})
-	}
-
-	return c.JSON(rc.GetStats())
-}
-
-// getWebSocketStats returns WebSocket statistics
-func (ad *AdminDashboard) getWebSocketStats(c *fiber.Ctx) error {
-	wsp := GetWebSocketProxy()
-
-	if wsp == nil {
-		return c.JSON(map[string]interface{}{
-			"enabled": false,
-		})
-	}
-
-	return c.JSON(wsp.GetStats())
-}
-
-// clearCache clears the cache
-func (ad *AdminDashboard) clearCache(c *fiber.Ctx) error {
-	libpack_cache.CacheClear()
-	return c.JSON(map[string]interface{}{
-		"success": true,
-		"message": "Cache cleared successfully",
-	})
-}
-
-// resetRetryBudget resets retry budget statistics
-func (ad *AdminDashboard) resetRetryBudget(c *fiber.Ctx) error {
-	rb := GetRetryBudget()
-	if rb != nil {
-		rb.Reset()
-	}
-
-	return c.JSON(map[string]interface{}{
-		"success": true,
-		"message": "Retry budget statistics reset",
-	})
-}
-
-// resetCoalescing resets coalescing statistics
-func (ad *AdminDashboard) resetCoalescing(c *fiber.Ctx) error {
-	rc := GetRequestCoalescer()
-	if rc != nil {
-		rc.Reset()
-	}
-
-	return c.JSON(map[string]interface{}{
-		"success": true,
-		"message": "Coalescing statistics reset",
-	})
-}
-
-// getClusterStats returns aggregated statistics from all proxy instances
-func (ad *AdminDashboard) getClusterStats(c *fiber.Ctx) error {
-	aggregator := GetMetricsAggregator()
-	if aggregator == nil {
-		return c.Status(503).JSON(map[string]interface{}{
-			"error":        "Cluster mode not available",
-			"message":      "Redis-based metrics aggregation is not enabled",
-			"cluster_mode": false,
-		})
-	}
-
-	metrics, err := aggregator.GetAggregatedMetrics()
-	if err != nil {
-		if ad.logger != nil {
-			ad.logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to get aggregated metrics",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
-		return c.Status(500).JSON(map[string]interface{}{
-			"error":   "Failed to retrieve cluster metrics",
-			"message": err.Error(),
-		})
-	}
-
-	// Format response similar to regular stats endpoint
-	response := map[string]interface{}{
-		"cluster_mode":      true,
-		"total_instances":   metrics.TotalInstances,
-		"healthy_instances": metrics.HealthyInstances,
-		"last_update":       metrics.LastUpdate.Format(time.RFC3339),
-		"stats":             metrics.CombinedStats,
-	}
-
-	return c.JSON(response)
-}
-
-// getClusterInstances returns detailed metrics for each proxy instance
-func (ad *AdminDashboard) getClusterInstances(c *fiber.Ctx) error {
-	aggregator := GetMetricsAggregator()
-	if aggregator == nil {
-		return c.Status(503).JSON(map[string]interface{}{
-			"error":        "Cluster mode not available",
-			"message":      "Redis-based metrics aggregation is not enabled",
-			"cluster_mode": false,
-		})
-	}
-
-	metrics, err := aggregator.GetAggregatedMetrics()
-	if err != nil {
-		if ad.logger != nil {
-			ad.logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to get instance metrics",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
-		return c.Status(500).JSON(map[string]interface{}{
-			"error":   "Failed to retrieve instance metrics",
-			"message": err.Error(),
-		})
-	}
-
-	return c.JSON(map[string]interface{}{
-		"cluster_mode":      true,
-		"total_instances":   metrics.TotalInstances,
-		"healthy_instances": metrics.HealthyInstances,
-		"current_instance":  aggregator.GetInstanceID(),
-		"instances":         metrics.Instances,
-	})
-}
-
-// getClusterDebug returns debug information about cluster mode
-func (ad *AdminDashboard) getClusterDebug(c *fiber.Ctx) error {
-	aggregator := GetMetricsAggregator()
-
-	debug := map[string]interface{}{
-		"aggregator_initialized": aggregator != nil,
-		"redis_cache_enabled":    false,
-	}
-
-	if cfg != nil {
-		debug["redis_cache_enabled"] = cfg.Cache.CacheRedisEnable
-		debug["cache_enabled"] = cfg.Cache.CacheEnable
-	}
-
-	if aggregator != nil {
-		debug["instance_id"] = aggregator.GetInstanceID()
-		debug["is_cluster_mode"] = aggregator.IsClusterMode()
-
-		// Try to get metrics
-		metrics, err := aggregator.GetAggregatedMetrics()
-		if err != nil {
-			debug["error"] = err.Error()
-		} else {
-			debug["total_instances"] = metrics.TotalInstances
-			debug["healthy_instances"] = metrics.HealthyInstances
-
-			// Show first instance structure as example
-			if len(metrics.Instances) > 0 {
-				first := metrics.Instances[0]
-				debug["sample_instance"] = map[string]interface{}{
-					"instance_id":    first.InstanceID,
-					"hostname":       first.Hostname,
-					"uptime_seconds": first.UptimeSeconds,
-					"stats_keys":     getMapKeys(first.Stats),
-					"has_requests":   first.Stats["requests"] != nil,
-					"has_cache":      len(first.CacheSummary) > 0,
-					"health_status":  first.Health["status"],
-				}
-
-				// Show requests structure if it exists
-				if requests, ok := first.Stats["requests"].(map[string]interface{}); ok {
-					debug["sample_requests"] = requests
-				}
-			}
-		}
-	}
-
-	return c.JSON(debug)
-}
-
-// Helper to get map keys
-func getMapKeys(m map[string]interface{}) []string {
-	keys := make([]string, 0, len(m))
-	for k := range m {
-		keys = append(keys, k)
-	}
-	return keys
-}
-
-// forcePublish forces an immediate metrics publish for testing
-func (ad *AdminDashboard) forcePublish(c *fiber.Ctx) error {
-	aggregator := GetMetricsAggregator()
-	if aggregator == nil {
-		return c.Status(503).JSON(map[string]interface{}{
-			"error":   "Aggregator not initialized",
-			"success": false,
-		})
-	}
-
-	// Trigger publish in goroutine to avoid blocking
-	go aggregator.publishMetrics()
-
-	return c.JSON(map[string]interface{}{
-		"success":   true,
-		"triggered": true,
-		"message":   "Publish triggered in background",
-		"next_steps": []string{
-			"Wait 2 seconds",
-			"Check GET /admin/api/cluster/debug",
-			"Check server logs for ✓ Successfully published or ❌ CRITICAL errors",
-		},
-	})
-}
-
-// Helper to get metric value for admin dashboard
-func getAdminMetricValue(name string) int64 {
-	if cfg == nil || cfg.Monitoring == nil {
-		return 0
-	}
-	counter := cfg.Monitoring.RegisterMetricsCounter(name, nil)
-	if counter == nil {
-		return 0
-	}
-	return int64(counter.Get())
-}
-
-// handleStatsWebSocket handles WebSocket connections for streaming statistics
-func (ad *AdminDashboard) handleStatsWebSocket(c *websocket.Conn) {
-	if ad.logger != nil {
-		ad.logger.Info(&libpack_logger.LogMessage{
-			Message: "WebSocket client connected to stats stream",
-			Pairs: map[string]interface{}{
-				"remote_addr": c.RemoteAddr().String(),
-			},
-		})
-	}
-
-	// Cleanup on disconnect
-	defer func() {
-		if ad.logger != nil {
-			ad.logger.Info(&libpack_logger.LogMessage{
-				Message: "WebSocket client disconnected from stats stream",
-				Pairs: map[string]interface{}{
-					"remote_addr": c.RemoteAddr().String(),
-				},
-			})
-		}
-		c.Close()
-	}()
-
-	// Set up ping/pong handlers
-	c.SetReadDeadline(time.Now().Add(60 * time.Second))
-	c.SetPongHandler(func(string) error {
-		c.SetReadDeadline(time.Now().Add(60 * time.Second))
-		return nil
-	})
-
-	// Channel to signal when to stop
-	done := make(chan struct{})
-
-	// Goroutine to handle incoming messages (for connection keep-alive)
-	go func() {
-		defer close(done)
-		for {
-			if _, _, err := c.ReadMessage(); err != nil {
-				// Connection closed or error
-				return
-			}
-		}
-	}()
-
-	// Stream statistics every 2 seconds
-	ticker := time.NewTicker(2 * time.Second)
-	defer ticker.Stop()
-
-	// Send initial stats immediately (cluster-aware for dashboard)
-	if stats := ad.gatherAllStatsClusterAware(); stats != nil {
-		if data, err := json.Marshal(stats); err == nil {
-			c.WriteMessage(websocket.TextMessage, data)
-		}
-	}
-
-	// Stream loop
-	for {
-		select {
-		case <-ticker.C:
-			// Gather all stats (cluster-aware for dashboard)
-			stats := ad.gatherAllStatsClusterAware()
-
-			// Marshal to JSON
-			data, err := json.Marshal(stats)
-			if err != nil {
-				if ad.logger != nil {
-					ad.logger.Error(&libpack_logger.LogMessage{
-						Message: "Failed to marshal stats for WebSocket",
-						Pairs:   map[string]interface{}{"error": err.Error()},
-					})
-				}
-				return
-			}
-
-			// Send to client
-			if err := c.WriteMessage(websocket.TextMessage, data); err != nil {
-				if ad.logger != nil {
-					ad.logger.Debug(&libpack_logger.LogMessage{
-						Message: "Failed to write to WebSocket (client likely disconnected)",
-						Pairs:   map[string]interface{}{"error": err.Error()},
-					})
-				}
-				return
-			}
-
-		case <-done:
-			// Client disconnected
-			return
-		}
-	}
-}
-
-// gatherAllStats collects all statistics into a single structure
-// This always returns LOCAL stats for this instance (used by metrics aggregator)
-func (ad *AdminDashboard) gatherAllStats() map[string]interface{} {
-	return ad.gatherAllStatsWithMode(false)
-}
-
-// gatherAllStatsClusterAware collects statistics with cluster awareness
-// If cluster mode is available, returns aggregated stats from all instances
-func (ad *AdminDashboard) gatherAllStatsClusterAware() map[string]interface{} {
-	return ad.gatherAllStatsWithMode(true)
-}
-
-// gatherAllStatsWithMode collects statistics with optional cluster mode
-func (ad *AdminDashboard) gatherAllStatsWithMode(useClusterMode bool) map[string]interface{} {
-	// Check if cluster mode is requested and available
-	if useClusterMode {
-		if aggregator := GetMetricsAggregator(); aggregator != nil {
-			metrics, err := aggregator.GetAggregatedMetrics()
-			if err == nil && metrics != nil {
-				// Return aggregated cluster stats
-				result := map[string]interface{}{
-					"cluster_mode":      true,
-					"total_instances":   metrics.TotalInstances,
-					"healthy_instances": metrics.HealthyInstances,
-				}
-
-				// Build stats section from combined stats
-				stats := map[string]interface{}{
-					"timestamp": metrics.LastUpdate.Format(time.RFC3339),
-					"version":   "0.27.0",
-				}
-
-				// Copy all combined stats
-				if metrics.CombinedStats != nil {
-					for k, v := range metrics.CombinedStats {
-						stats[k] = v
-					}
-				}
-				result["stats"] = stats
-
-				// Add per-instance details
-				result["instances"] = metrics.Instances
-
-				return result
-			}
-		}
-	}
-
-	// Fall back to local stats
-	result := make(map[string]interface{})
-	result["cluster_mode"] = false
-
-	// Main stats
-	uptimeSeconds := time.Since(startTime).Seconds()
-	stats := map[string]interface{}{
-		"timestamp":      time.Now().Format(time.RFC3339),
-		"uptime_seconds": uptimeSeconds,
-		"uptime_human":   formatDuration(time.Since(startTime)),
-		"version":        "0.27.0",
-	}
-
-	if cfg != nil && cfg.Monitoring != nil {
-		succeeded := getAdminMetricValue("requests_succesful")
-		failed := getAdminMetricValue("requests_failed")
-		skipped := getAdminMetricValue("requests_skipped")
-		total := succeeded + failed + skipped
-
-		requestStats := map[string]interface{}{
-			"total":     total,
-			"succeeded": succeeded,
-			"failed":    failed,
-			"skipped":   skipped,
-		}
-
-		if total > 0 {
-			requestStats["success_rate_pct"] = float64(succeeded) / float64(total) * 100
-			requestStats["failure_rate_pct"] = float64(failed) / float64(total) * 100
-			requestStats["skip_rate_pct"] = float64(skipped) / float64(total) * 100
-		} else {
-			requestStats["success_rate_pct"] = 0.0
-			requestStats["failure_rate_pct"] = 0.0
-			requestStats["skip_rate_pct"] = 0.0
-		}
-
-		if uptimeSeconds > 0 {
-			requestStats["avg_requests_per_second"] = float64(total) / uptimeSeconds
-		} else {
-			requestStats["avg_requests_per_second"] = 0.0
-		}
-
-		if rpsTracker := GetRPSTracker(); rpsTracker != nil {
-			requestStats["current_requests_per_second"] = rpsTracker.GetCurrentRPS()
-		} else {
-			requestStats["current_requests_per_second"] = 0.0
-		}
-
-		stats["requests"] = requestStats
-
-		// Cache summary
-		cacheStats := libpack_cache.GetCacheStats()
-		if cacheStats != nil {
-			totalCacheRequests := cacheStats.CacheHits + cacheStats.CacheMisses
-			hitRate := 0.0
-			if totalCacheRequests > 0 {
-				hitRate = float64(cacheStats.CacheHits) / float64(totalCacheRequests) * 100
-			}
-			stats["cache_summary"] = map[string]interface{}{
-				"hits":         cacheStats.CacheHits,
-				"misses":       cacheStats.CacheMisses,
-				"hit_rate_pct": hitRate,
-				"total_cached": cacheStats.CachedQueries,
-			}
-		}
-	}
-
-	result["stats"] = stats
-
-	// Health
-	healthMgr := GetBackendHealthManager()
-	health := map[string]interface{}{
-		"status": "unknown",
-		"backend": map[string]interface{}{
-			"healthy": false,
-		},
-	}
-
-	if healthMgr != nil {
-		isHealthy := healthMgr.IsHealthy()
-		health["backend"] = map[string]interface{}{
-			"healthy":              isHealthy,
-			"consecutive_failures": healthMgr.GetConsecutiveFailures(),
-			"last_check":           healthMgr.GetLastHealthCheck().Format(time.RFC3339),
-		}
-
-		if isHealthy {
-			health["status"] = "healthy"
-		} else {
-			health["status"] = "unhealthy"
-		}
-	}
-	result["health"] = health
-
-	// Circuit breaker
-	cbStatus := map[string]interface{}{
-		"enabled": false,
-		"state":   "unknown",
-	}
-
-	if cfg != nil {
-		cbStatus["enabled"] = cfg.CircuitBreaker.Enable
-
-		if cb != nil {
-			cbMutex.RLock()
-			state := cb.State()
-			counts := cb.Counts()
-			cbMutex.RUnlock()
-
-			cbStatus["state"] = state.String()
-			cbStatus["counts"] = map[string]interface{}{
-				"requests":              counts.Requests,
-				"total_successes":       counts.TotalSuccesses,
-				"total_failures":        counts.TotalFailures,
-				"consecutive_successes": counts.ConsecutiveSuccesses,
-				"consecutive_failures":  counts.ConsecutiveFailures,
-			}
-			cbStatus["config"] = map[string]interface{}{
-				"max_failures":           cfg.CircuitBreaker.MaxFailures,
-				"failure_ratio":          cfg.CircuitBreaker.FailureRatio,
-				"timeout":                cfg.CircuitBreaker.Timeout,
-				"max_requests_half_open": cfg.CircuitBreaker.MaxRequestsInHalfOpen,
-				"return_cached_on_open":  cfg.CircuitBreaker.ReturnCachedOnOpen,
-			}
-		}
-	}
-	result["circuit_breaker"] = cbStatus
-
-	// Cache stats
-	cacheStats := map[string]interface{}{
-		"enabled": false,
-	}
-
-	if cfg != nil {
-		cacheStats["enabled"] = cfg.Cache.CacheEnable
-		cacheStats["redis_enabled"] = cfg.Cache.CacheRedisEnable
-		cacheStats["ttl_seconds"] = cfg.Cache.CacheTTL
-		cacheStats["max_memory_mb"] = cfg.Cache.CacheMaxMemorySize
-		cacheStats["max_entries"] = cfg.Cache.CacheMaxEntries
-
-		runtimeCacheStats := libpack_cache.GetCacheStats()
-		if runtimeCacheStats != nil {
-			cacheStats["cached_queries"] = runtimeCacheStats.CachedQueries
-			cacheStats["cache_hits"] = runtimeCacheStats.CacheHits
-			cacheStats["cache_misses"] = runtimeCacheStats.CacheMisses
-
-			totalRequests := runtimeCacheStats.CacheHits + runtimeCacheStats.CacheMisses
-			hitRate := 0.0
-			if totalRequests > 0 {
-				hitRate = float64(runtimeCacheStats.CacheHits) / float64(totalRequests) * 100
-			}
-			cacheStats["hit_rate_pct"] = hitRate
-
-			// Only get memory usage for in-memory cache (not Redis)
-			if cfg.Cache.CacheEnable && !cfg.Cache.CacheRedisEnable {
-				memoryUsage := libpack_cache.GetCacheMemoryUsage()
-				maxMemory := libpack_cache.GetCacheMaxMemorySize()
-				cacheStats["memory_usage_bytes"] = memoryUsage
-				cacheStats["memory_usage_mb"] = float64(memoryUsage) / (1024 * 1024)
-
-				memoryUsagePct := 0.0
-				if maxMemory > 0 {
-					memoryUsagePct = float64(memoryUsage) / float64(maxMemory) * 100
-				}
-				cacheStats["memory_usage_pct"] = memoryUsagePct
-			} else {
-				// For Redis cache, memory tracking is not available per instance
-				cacheStats["memory_usage_bytes"] = int64(-1)
-				cacheStats["memory_usage_mb"] = float64(-1)
-				cacheStats["memory_usage_pct"] = float64(-1)
-			}
-		}
-	}
-	result["cache"] = cacheStats
-
-	// Connection stats
-	poolMgr := GetConnectionPoolManager()
-	connStats := map[string]interface{}{
-		"available": false,
-	}
-
-	if poolMgr != nil {
-		connStats = poolMgr.GetConnectionStats()
-		connStats["available"] = true
-	}
-	result["connections"] = connStats
-
-	// Retry budget
-	rb := GetRetryBudget()
-	if rb == nil {
-		result["retry_budget"] = map[string]interface{}{"enabled": false}
-	} else {
-		result["retry_budget"] = rb.GetStats()
-	}
-
-	// Coalescing
-	rc := GetRequestCoalescer()
-	if rc == nil {
-		result["coalescing"] = map[string]interface{}{"enabled": false}
-	} else {
-		result["coalescing"] = rc.GetStats()
-	}
-
-	// WebSocket
-	wsp := GetWebSocketProxy()
-	if wsp == nil {
-		result["websocket"] = map[string]interface{}{"enabled": false}
-	} else {
-		result["websocket"] = wsp.GetStats()
-	}
-
-	return result
-}
-
-var startTime = time.Now()

admin_dashboard_test.go

@@ -1,504 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"io"
-	"net/http/httptest"
-	"testing"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewAdminDashboard(t *testing.T) {
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	assert.NotNil(t, dashboard)
-	assert.Equal(t, logger, dashboard.logger)
-}
-
-func TestAdminDashboard_RegisterRoutes(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	// Verify routes are registered by checking app
-	routes := app.GetRoutes()
-
-	expectedRoutes := map[string]bool{
-		"/admin":                        false,
-		"/admin/dashboard":              false,
-		"/admin/api/stats":              false,
-		"/admin/api/health":             false,
-		"/admin/api/circuit-breaker":    false,
-		"/admin/api/cache":              false,
-		"/admin/api/connections":        false,
-		"/admin/api/retry-budget":       false,
-		"/admin/api/coalescing":         false,
-		"/admin/api/websocket":          false,
-		"/admin/api/cache/clear":        false,
-		"/admin/api/retry-budget/reset": false,
-		"/admin/api/coalescing/reset":   false,
-	}
-
-	for _, route := range routes {
-		if _, exists := expectedRoutes[route.Path]; exists {
-			expectedRoutes[route.Path] = true
-		}
-	}
-
-	// Verify all expected routes were found
-	for path, found := range expectedRoutes {
-		assert.True(t, found, "Route %s should be registered", path)
-	}
-}
-
-func TestAdminDashboard_ServeDashboard(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Verify content type
-	contentType := resp.Header.Get("Content-Type")
-	assert.Contains(t, contentType, "text/html")
-
-	// Verify HTML content is returned
-	body, err := io.ReadAll(resp.Body)
-	assert.NoError(t, err)
-	assert.Contains(t, string(body), "GraphQL Proxy Admin Dashboard")
-}
-
-func TestAdminDashboard_GetStats(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	monitoring := libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{})
-
-	// Initialize global config for testing
-	cfg = &config{
-		Logger:     logger,
-		Monitoring: monitoring,
-	}
-
-	dashboard := NewAdminDashboard(logger)
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/stats", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var stats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &stats)
-	assert.NoError(t, err)
-
-	// Verify stats structure
-	assert.NotEmpty(t, stats["timestamp"])
-	assert.NotNil(t, stats["uptime_seconds"])
-	assert.NotNil(t, stats["uptime_human"])
-	assert.NotEmpty(t, stats["version"])
-	assert.NotNil(t, stats["requests"])
-
-	// Verify request stats structure
-	requests := stats["requests"].(map[string]interface{})
-	assert.NotNil(t, requests["total"])
-	assert.NotNil(t, requests["succeeded"])
-	assert.NotNil(t, requests["failed"])
-	assert.NotNil(t, requests["success_rate_pct"])
-	assert.NotNil(t, requests["avg_requests_per_second"])
-	assert.NotNil(t, requests["current_requests_per_second"])
-}
-
-func TestAdminDashboard_GetHealth(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/health", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var health map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &health)
-	assert.NoError(t, err)
-
-	// Verify health structure
-	assert.NotNil(t, health["status"])
-	assert.NotNil(t, health["backend"])
-}
-
-func TestAdminDashboard_GetCircuitBreakerStatus(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	// Initialize global config
-	cfg = &config{
-		Logger: logger,
-		CircuitBreaker: struct {
-			EndpointConfigs       map[string]*EndpointCBConfig
-			ExcludedStatusCodes   []int
-			MaxFailures           int
-			FailureRatio          float64
-			SampleSize            int
-			Timeout               int
-			MaxRequestsInHalfOpen int
-			MaxBackoffTimeout     int
-			BackoffMultiplier     float64
-			ReturnCachedOnOpen    bool
-			TripOn4xx             bool
-			TripOn5xx             bool
-			TripOnTimeouts        bool
-			Enable                bool
-		}{
-			Enable:      true,
-			MaxFailures: 10,
-			Timeout:     60,
-		},
-	}
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/circuit-breaker", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var status map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &status)
-	assert.NoError(t, err)
-
-	// Verify status structure
-	assert.NotNil(t, status["enabled"])
-	assert.NotNil(t, status["state"])
-}
-
-func TestAdminDashboard_GetCacheStats(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	cfg = &config{
-		Logger: logger,
-		Cache: struct {
-			CacheRedisURL         string
-			CacheRedisPassword    string
-			CacheTTL              int
-			CacheRedisDB          int
-			CacheEnable           bool
-			CacheRedisEnable      bool
-			CacheMaxMemorySize    int
-			CacheMaxEntries       int
-			CacheUseLRU           bool
-			GraphQLQueryCacheSize int
-			PerUserCacheDisabled  bool
-		}{
-			CacheEnable:          true,
-			CacheTTL:             60,
-			CacheMaxMemorySize:   100,
-			CacheMaxEntries:      10000,
-			CacheUseLRU:          false,
-			PerUserCacheDisabled: false,
-		},
-	}
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/cache", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var stats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &stats)
-	assert.NoError(t, err)
-
-	// Verify stats structure
-	assert.NotNil(t, stats["enabled"])
-	assert.NotNil(t, stats["ttl_seconds"])
-}
-
-func TestAdminDashboard_GetConnectionStats(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/connections", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var stats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &stats)
-	assert.NoError(t, err)
-
-	// Verify stats structure
-	assert.NotNil(t, stats["available"])
-}
-
-func TestAdminDashboard_GetRetryBudgetStats(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/retry-budget", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var stats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &stats)
-	assert.NoError(t, err)
-
-	// When no retry budget is initialized, should have "enabled" field
-	assert.NotNil(t, stats)
-}
-
-func TestAdminDashboard_GetCoalescingStats(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/coalescing", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var stats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &stats)
-	assert.NoError(t, err)
-
-	// When no coalescer is initialized, should have "enabled" field
-	assert.NotNil(t, stats)
-}
-
-func TestAdminDashboard_GetWebSocketStats(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("GET", "/admin/api/websocket", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var stats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &stats)
-	assert.NoError(t, err)
-
-	// When no WebSocket proxy is initialized, should have "enabled" field
-	assert.NotNil(t, stats)
-}
-
-func TestAdminDashboard_ClearCache(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("POST", "/admin/api/cache/clear", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var result map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &result)
-	assert.NoError(t, err)
-
-	assert.Equal(t, true, result["success"])
-	assert.NotEmpty(t, result["message"])
-}
-
-func TestAdminDashboard_ResetRetryBudget(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	dashboard := NewAdminDashboard(logger)
-
-	// Initialize retry budget
-	config := RetryBudgetConfig{
-		TokensPerSecond: 10.0,
-		MaxTokens:       100,
-		Enabled:         true,
-	}
-	InitializeRetryBudget(config, logger)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("POST", "/admin/api/retry-budget/reset", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var result map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &result)
-	assert.NoError(t, err)
-
-	assert.Equal(t, true, result["success"])
-	assert.NotEmpty(t, result["message"])
-}
-
-func TestAdminDashboard_ResetCoalescing(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-	monitoring := libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{})
-	dashboard := NewAdminDashboard(logger)
-
-	// Initialize request coalescer
-	InitializeRequestCoalescer(true, logger, monitoring)
-
-	dashboard.RegisterRoutes(app)
-
-	req := httptest.NewRequest("POST", "/admin/api/coalescing/reset", nil)
-	resp, err := app.Test(req)
-
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	// Parse response
-	var result map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	err = json.Unmarshal(body, &result)
-	assert.NoError(t, err)
-
-	assert.Equal(t, true, result["success"])
-	assert.NotEmpty(t, result["message"])
-}
-
-func TestGetAdminMetricValue(t *testing.T) {
-	logger := libpack_logger.New()
-	monitoring := libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{})
-
-	cfg = &config{
-		Logger:     logger,
-		Monitoring: monitoring,
-	}
-
-	// Test with valid metric
-	value := getAdminMetricValue("requests_succesful")
-	assert.GreaterOrEqual(t, value, int64(0))
-
-	// Test with nil config
-	oldCfg := cfg
-	cfg = nil
-	value = getAdminMetricValue("requests_succesful")
-	assert.Equal(t, int64(0), value)
-	cfg = oldCfg
-}
-
-func TestAdminDashboard_StartTime(t *testing.T) {
-	// Verify startTime is initialized
-	assert.NotZero(t, startTime)
-	assert.True(t, time.Since(startTime) >= 0)
-}
-
-func TestAdminDashboard_IntegrationWithFeatures(t *testing.T) {
-	app := fiber.New()
-	logger := libpack_logger.New()
-
-	// Initialize all features
-	rbConfig := RetryBudgetConfig{
-		TokensPerSecond: 10.0,
-		MaxTokens:       100,
-		Enabled:         true,
-	}
-	InitializeRetryBudget(rbConfig, logger)
-	InitializeRequestCoalescer(true, logger, nil)
-
-	wsConfig := WebSocketConfig{
-		Enabled:        true,
-		PingInterval:   30 * time.Second,
-		MaxMessageSize: 512 * 1024,
-	}
-	InitializeWebSocketProxy("http://localhost:8080", wsConfig, logger, nil)
-
-	dashboard := NewAdminDashboard(logger)
-	dashboard.RegisterRoutes(app)
-
-	// Test retry budget endpoint
-	req := httptest.NewRequest("GET", "/admin/api/retry-budget", nil)
-	resp, err := app.Test(req)
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	var rbStats map[string]interface{}
-	body, _ := io.ReadAll(resp.Body)
-	json.Unmarshal(body, &rbStats)
-	assert.Equal(t, true, rbStats["enabled"])
-
-	// Test coalescing endpoint
-	req = httptest.NewRequest("GET", "/admin/api/coalescing", nil)
-	resp, err = app.Test(req)
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	var coalStats map[string]interface{}
-	body, _ = io.ReadAll(resp.Body)
-	json.Unmarshal(body, &coalStats)
-	assert.Equal(t, true, coalStats["enabled"])
-
-	// Test WebSocket endpoint
-	req = httptest.NewRequest("GET", "/admin/api/websocket", nil)
-	resp, err = app.Test(req)
-	assert.NoError(t, err)
-	assert.Equal(t, 200, resp.StatusCode)
-
-	var wsStats map[string]interface{}
-	body, _ = io.ReadAll(resp.Body)
-	json.Unmarshal(body, &wsStats)
-	assert.Equal(t, true, wsStats["enabled"])
-}

api.go

@@ -1,8 +1,6 @@
 package main
 
 import (
-	"context"
-	"crypto/subtle"
 	"fmt"
 	"os"
 	"sync"
@@ -14,7 +12,6 @@ import (
 	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/sony/gobreaker"
 )
 
 var (
@@ -22,43 +19,9 @@ var (
 	bannedUsersIDsMutex sync.RWMutex
 )
 
-// authMiddleware provides API key authentication for admin endpoints
-func authMiddleware(c *fiber.Ctx) error {
-	apiKey := c.Get("X-API-Key")
-
-	// Get expected key from config (try GMP_ prefix first, then fallback)
-	expectedKey := os.Getenv("GMP_ADMIN_API_KEY")
-	if expectedKey == "" {
-		expectedKey = os.Getenv("ADMIN_API_KEY")
-	}
-
-	// If no API key is configured, authentication is optional (internal service pattern)
-	// Admin endpoints are typically protected by network segmentation
-	if expectedKey == "" {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Admin API authentication disabled - endpoints protected by network segmentation",
-			Pairs:   map[string]interface{}{"endpoint": c.Path()},
-		})
-		return c.Next()
-	}
-
-	// Use constant-time comparison to prevent timing attacks
-	if subtle.ConstantTimeCompare([]byte(apiKey), []byte(expectedKey)) != 1 {
-		cfg.Logger.Warning(&libpack_logger.LogMessage{
-			Message: "Unauthorized API access attempt",
-			Pairs:   map[string]interface{}{"endpoint": c.Path(), "ip": c.IP()},
-		})
-		return c.Status(fiber.StatusUnauthorized).JSON(fiber.Map{
-			"error": "Unauthorized",
-		})
-	}
-
-	return c.Next()
-}
-
-func enableApi(ctx context.Context) error {
+func enableApi() {
 	if !cfg.Server.EnableApi {
-		return nil
+		return
 	}
 
 	apiserver := fiber.New(fiber.Config{
@@ -67,57 +30,31 @@ func enableApi(ctx context.Context) error {
 	})
 
 	api := apiserver.Group("/api")
-	// Apply authentication middleware to all admin routes
-	api.Use(authMiddleware)
 	api.Post("/user-ban", apiBanUser)
 	api.Post("/user-unban", apiUnbanUser)
 	api.Post("/cache-clear", apiClearCache)
 	api.Get("/cache-stats", apiCacheStats)
-	api.Get("/circuit-breaker/health", apiCircuitBreakerHealth)
-	api.Get("/backend/health", apiBackendHealth)
-	api.Get("/connection-pool/health", apiConnectionPoolHealth)
 
-	// Start banned users reload in a separate goroutine with context
-	go periodicallyReloadBannedUsers(ctx)
+	go periodicallyReloadBannedUsers()
 
-	// Start server in a goroutine and handle shutdown
-	errCh := make(chan error, 1)
-	go func() {
-		if err := apiserver.Listen(fmt.Sprintf(":%d", cfg.Server.ApiPort)); err != nil {
-			errCh <- err
-		}
-	}()
-
-	// Wait for context cancellation or error
-	select {
-	case <-ctx.Done():
-		cfg.Logger.Info(&libpack_logger.LogMessage{
-			Message: "Shutting down API server",
+	if err := apiserver.Listen(fmt.Sprintf(":%d", cfg.Server.ApiPort)); err != nil {
+		cfg.Logger.Critical(&libpack_logger.LogMessage{
+			Message: "Can't start the service",
+			Pairs:   map[string]interface{}{"port": cfg.Server.ApiPort},
 		})
-		return apiserver.Shutdown()
-	case err := <-errCh:
-		return err
 	}
 }
 
-func periodicallyReloadBannedUsers(ctx context.Context) {
+func periodicallyReloadBannedUsers() {
 	ticker := time.NewTicker(10 * time.Second)
 	defer ticker.Stop()
 
-	for {
-		select {
-		case <-ctx.Done():
-			cfg.Logger.Info(&libpack_logger.LogMessage{
-				Message: "Stopping banned users reload",
-			})
-			return
-		case <-ticker.C:
-			loadBannedUsers()
-			cfg.Logger.Debug(&libpack_logger.LogMessage{
-				Message: "Banned users reloaded",
-				Pairs:   map[string]interface{}{"users": bannedUsersIDs},
-			})
-		}
+	for range ticker.C {
+		loadBannedUsers()
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Banned users reloaded",
+			Pairs:   map[string]interface{}{"users": bannedUsersIDs},
+		})
 	}
 }
 
@@ -136,12 +73,7 @@ func checkIfUserIsBanned(c *fiber.Ctx, userID string) bool {
 			Message: "User is banned",
 			Pairs:   map[string]interface{}{"user_id": userID},
 		})
-		if err := c.Status(fiber.StatusForbidden).SendString("User is banned"); err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to send banned user response",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
+		c.Status(fiber.StatusForbidden).SendString("User is banned")
 	}
 	return found
 }
@@ -161,60 +93,6 @@ func apiCacheStats(c *fiber.Ctx) error {
 	return c.JSON(libpack_cache.GetCacheStats())
 }
 
-// apiCircuitBreakerHealth returns the health status of the circuit breaker
-func apiCircuitBreakerHealth(c *fiber.Ctx) error {
-	if cb == nil {
-		return c.Status(fiber.StatusServiceUnavailable).JSON(fiber.Map{
-			"status":  "disabled",
-			"message": "Circuit breaker is not enabled",
-		})
-	}
-
-	// Get circuit breaker state with proper mutex protection
-	cbMutex.RLock()
-	state := cb.State()
-	counts := cb.Counts()
-	cbMutex.RUnlock()
-
-	// Determine health status
-	var status string
-	var httpStatus int
-
-	switch state {
-	case gobreaker.StateClosed:
-		status = "healthy"
-		httpStatus = fiber.StatusOK
-	case gobreaker.StateHalfOpen:
-		status = "recovering"
-		httpStatus = fiber.StatusOK
-	case gobreaker.StateOpen:
-		status = "unhealthy"
-		httpStatus = fiber.StatusServiceUnavailable
-	}
-
-	response := fiber.Map{
-		"status": status,
-		"state":  state.String(),
-		"counts": fiber.Map{
-			"requests":              counts.Requests,
-			"total_successes":       counts.TotalSuccesses,
-			"total_failures":        counts.TotalFailures,
-			"consecutive_successes": counts.ConsecutiveSuccesses,
-			"consecutive_failures":  counts.ConsecutiveFailures,
-		},
-		"configuration": fiber.Map{
-			"max_failures":       cfg.CircuitBreaker.MaxFailures,
-			"failure_ratio":      cfg.CircuitBreaker.FailureRatio,
-			"sample_size":        cfg.CircuitBreaker.SampleSize,
-			"timeout_seconds":    cfg.CircuitBreaker.Timeout,
-			"max_half_open_reqs": cfg.CircuitBreaker.MaxRequestsInHalfOpen,
-			"backoff_multiplier": cfg.CircuitBreaker.BackoffMultiplier,
-		},
-	}
-
-	return c.Status(httpStatus).JSON(response)
-}
-
 type apiBanUserRequest struct {
 	UserID string `json:"user_id"`
 	Reason string `json:"reason"`
@@ -285,14 +163,7 @@ func storeBannedUsers() error {
 	if err := lockFile(fileLock); err != nil {
 		return err
 	}
-	defer func() {
-		if err := fileLock.Unlock(); err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to unlock file",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
-	}()
+	defer fileLock.Unlock()
 
 	bannedUsersIDsMutex.RLock()
 	data, err := json.Marshal(bannedUsersIDs)
@@ -306,7 +177,7 @@ func storeBannedUsers() error {
 		return err
 	}
 
-	if err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0o644); err != nil {
+	if err := os.WriteFile(cfg.Api.BannedUsersFile, data, 0644); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Can't write banned users to file",
 			Pairs:   map[string]interface{}{"error": err.Error()},
@@ -323,7 +194,7 @@ func loadBannedUsers() {
 			Message: "Banned users file doesn't exist - creating it",
 			Pairs:   map[string]interface{}{"file": cfg.Api.BannedUsersFile},
 		})
-		if err := os.WriteFile(cfg.Api.BannedUsersFile, []byte("{}"), 0o644); err != nil {
+		if err := os.WriteFile(cfg.Api.BannedUsersFile, []byte("{}"), 0644); err != nil {
 			cfg.Logger.Error(&libpack_logger.LogMessage{
 				Message: "Can't create and write to the file",
 				Pairs:   map[string]interface{}{"error": err.Error()},
@@ -340,14 +211,7 @@ func loadBannedUsers() {
 		})
 		return
 	}
-	defer func() {
-		if err := fileLock.Unlock(); err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to unlock file",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
-	}()
+	defer fileLock.Unlock()
 
 	data, err := os.ReadFile(cfg.Api.BannedUsersFile)
 	if err != nil {
@@ -373,136 +237,23 @@ func loadBannedUsers() {
 }
 
 func lockFile(fileLock *flock.Flock) error {
-	// Add timeout to prevent indefinite blocking
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// Try to acquire lock with timeout
-	lockChan := make(chan error, 1)
-	go func() {
-		lockChan <- fileLock.Lock()
-	}()
-
-	select {
-	case err := <-lockChan:
-		if err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Can't lock the file",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-			return err
-		}
-		return nil
-	case <-ctx.Done():
+	if err := fileLock.Lock(); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "File lock timeout",
-			Pairs:   map[string]interface{}{"timeout": "30s"},
+			Message: "Can't lock the file",
+			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return fmt.Errorf("file lock timeout after 30 seconds")
+		return err
 	}
+	return nil
 }
 
 func lockFileRead(fileLock *flock.Flock) error {
-	// Add timeout to prevent indefinite blocking
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	// Try to acquire read lock with timeout
-	lockChan := make(chan error, 1)
-	go func() {
-		lockChan <- fileLock.RLock()
-	}()
-
-	select {
-	case err := <-lockChan:
-		if err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Can't lock the file for reading",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-			return err
-		}
-		return nil
-	case <-ctx.Done():
+	if err := fileLock.RLock(); err != nil {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "File read lock timeout",
-			Pairs:   map[string]interface{}{"timeout": "30s"},
+			Message: "Can't lock the file for reading",
+			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return fmt.Errorf("file read lock timeout after 30 seconds")
+		return err
 	}
-}
-
-// apiBackendHealth returns the health status of the GraphQL backend
-func apiBackendHealth(c *fiber.Ctx) error {
-	healthMgr := GetBackendHealthManager()
-	if healthMgr == nil {
-		return c.Status(fiber.StatusServiceUnavailable).JSON(fiber.Map{
-			"status":  "unknown",
-			"message": "Backend health manager not initialized",
-		})
-	}
-
-	isHealthy := healthMgr.IsHealthy()
-	lastCheck := healthMgr.GetLastHealthCheck()
-	consecutiveFailures := healthMgr.GetConsecutiveFailures()
-
-	var status string
-	var httpStatus int
-
-	if isHealthy {
-		status = "healthy"
-		httpStatus = fiber.StatusOK
-	} else {
-		status = "unhealthy"
-		httpStatus = fiber.StatusServiceUnavailable
-	}
-
-	response := fiber.Map{
-		"status":               status,
-		"backend_url":          cfg.Server.HostGraphQL,
-		"last_health_check":    lastCheck,
-		"consecutive_failures": consecutiveFailures,
-		"check_interval":       "5s",
-	}
-
-	return c.Status(httpStatus).JSON(response)
-}
-
-// apiConnectionPoolHealth returns the health status of the connection pool
-func apiConnectionPoolHealth(c *fiber.Ctx) error {
-	poolMgr := GetConnectionPoolManager()
-	if poolMgr == nil {
-		return c.Status(fiber.StatusServiceUnavailable).JSON(fiber.Map{
-			"status":  "unknown",
-			"message": "Connection pool manager not initialized",
-		})
-	}
-
-	stats := poolMgr.GetConnectionStats()
-	connectionFailures := stats["connection_failures"].(int64)
-
-	var status string
-	var httpStatus int
-
-	// Consider pool healthy if we haven't had too many recent failures
-	if connectionFailures < 10 {
-		status = "healthy"
-		httpStatus = fiber.StatusOK
-	} else {
-		status = "degraded"
-		httpStatus = fiber.StatusOK // Still return 200 since pool is functional
-	}
-
-	response := fiber.Map{
-		"status":                  status,
-		"active_connections":      stats["active_connections"],
-		"total_connections":       stats["total_connections"],
-		"connection_failures":     connectionFailures,
-		"last_recovery_attempt":   stats["last_recovery_attempt"],
-		"cleanup_interval":        "30s",
-		"keepalive_interval":      "15s",
-		"recovery_check_interval": "60s",
-	}
-
-	return c.Status(httpStatus).JSON(response)
+	return nil
 }

api_additional_test.go

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

api_auth_security_test.go

@@ -1,633 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/suite"
-)
-
-type APIAuthSecurityTestSuite struct {
-	suite.Suite
-	app            *fiber.App
-	originalLogger *libpack_logger.Logger
-	validAPIKey    string
-}
-
-func TestAPIAuthSecurityTestSuite(t *testing.T) {
-	suite.Run(t, new(APIAuthSecurityTestSuite))
-}
-
-func (suite *APIAuthSecurityTestSuite) SetupTest() {
-	// Setup test configuration
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New()
-	cfg.Cache.CacheEnable = true
-	cfg.Cache.CacheTTL = 300
-	cfg.Cache.CacheMaxMemorySize = 100
-	suite.originalLogger = cfg.Logger
-
-	// Initialize cache
-	libpack_cache.EnableCache(&libpack_cache.CacheConfig{
-		Logger: cfg.Logger,
-		TTL:    300,
-	})
-
-	// Initialize banned users map
-	bannedUsersIDs = make(map[string]string)
-
-	// Setup banned users file path
-	cfg.Api.BannedUsersFile = filepath.Join(os.TempDir(), "banned_users_auth_test.json")
-
-	// Set up test API key (will be overridden in specific tests)
-	suite.validAPIKey = "test-secure-api-key-12345"
-
-	// Create test Fiber app with authentication
-	suite.app = fiber.New(fiber.Config{
-		DisableStartupMessage: true,
-	})
-
-	// Setup API routes with authentication middleware
-	api := suite.app.Group("/api")
-	api.Use(authMiddleware)
-	api.Post("/user-ban", apiBanUser)
-	api.Post("/user-unban", apiUnbanUser)
-	api.Post("/cache-clear", apiClearCache)
-	api.Get("/cache-stats", apiCacheStats)
-}
-
-func (suite *APIAuthSecurityTestSuite) TearDownTest() {
-	// Clean up environment variables
-	os.Unsetenv("GMP_ADMIN_API_KEY")
-	os.Unsetenv("ADMIN_API_KEY")
-
-	// Clean up test files
-	if cfg != nil && cfg.Api.BannedUsersFile != "" {
-		_ = os.Remove(cfg.Api.BannedUsersFile)
-		_ = os.Remove(fmt.Sprintf("%s.lock", cfg.Api.BannedUsersFile))
-	}
-}
-
-// TestOptionalAuthentication tests that admin endpoints work without auth when no key is configured
-func (suite *APIAuthSecurityTestSuite) TestOptionalAuthentication() {
-	// Ensure no API key is set
-	os.Unsetenv("GMP_ADMIN_API_KEY")
-	os.Unsetenv("ADMIN_API_KEY")
-
-	tests := []struct {
-		body           map[string]interface{}
-		name           string
-		endpoint       string
-		method         string
-		description    string
-		expectedStatus int
-	}{
-		{
-			name:           "No auth - cache-stats",
-			endpoint:       "/api/cache-stats",
-			method:         "GET",
-			expectedStatus: 200,
-			description:    "Should allow access without API key when auth is disabled",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			var req *http.Request
-			var err error
-
-			if tt.body != nil {
-				bodyBytes, _ := json.Marshal(tt.body)
-				req, err = http.NewRequest(tt.method, tt.endpoint, bytes.NewReader(bodyBytes))
-				req.Header.Set("Content-Type", "application/json")
-			} else {
-				req, err = http.NewRequest(tt.method, tt.endpoint, nil)
-			}
-			suite.NoError(err)
-
-			resp, err := suite.app.Test(req)
-			suite.NoError(err)
-			suite.Equal(tt.expectedStatus, resp.StatusCode,
-				"Status code mismatch: %s", tt.description)
-		})
-	}
-}
-
-// TestAPIAuthentication tests various authentication scenarios when auth is enabled
-func (suite *APIAuthSecurityTestSuite) TestAPIAuthentication() {
-	// Set test API key to enable authentication
-	os.Setenv("GMP_ADMIN_API_KEY", suite.validAPIKey)
-	defer os.Unsetenv("GMP_ADMIN_API_KEY")
-	tests := []struct {
-		body           map[string]interface{}
-		name           string
-		apiKey         string
-		endpoint       string
-		method         string
-		description    string
-		expectedStatus int
-	}{
-		{
-			name:           "Missing API key header",
-			apiKey:         "",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject requests without API key",
-		},
-		{
-			name:           "Invalid API key",
-			apiKey:         "wrong-key",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject requests with invalid API key",
-		},
-		{
-			name:           "SQL injection in API key",
-			apiKey:         "' OR '1'='1",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject SQL injection attempts in API key",
-		},
-		{
-			name:           "XSS attempt in API key",
-			apiKey:         "<script>alert('xss')</script>",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject XSS attempts in API key",
-		},
-		{
-			name:           "Command injection in API key",
-			apiKey:         "key; rm -rf /",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject command injection attempts in API key",
-		},
-		{
-			name:           "Valid API key for user-ban",
-			apiKey:         suite.validAPIKey,
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 200,
-			description:    "Should accept valid API key for user-ban endpoint",
-		},
-		{
-			name:           "Valid API key for user-unban",
-			apiKey:         suite.validAPIKey,
-			endpoint:       "/api/user-unban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test unban"},
-			expectedStatus: 200,
-			description:    "Should accept valid API key for user-unban endpoint",
-		},
-		{
-			name:           "Valid API key for cache-clear",
-			apiKey:         suite.validAPIKey,
-			endpoint:       "/api/cache-clear",
-			method:         "POST",
-			body:           nil,
-			expectedStatus: 200,
-			description:    "Should accept valid API key for cache-clear endpoint",
-		},
-		{
-			name:           "Valid API key for cache-stats",
-			apiKey:         suite.validAPIKey,
-			endpoint:       "/api/cache-stats",
-			method:         "GET",
-			body:           nil,
-			expectedStatus: 200,
-			description:    "Should accept valid API key for cache-stats endpoint",
-		},
-		{
-			name:           "Case sensitive API key",
-			apiKey:         strings.ToUpper(suite.validAPIKey),
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject case-modified API key (case sensitive)",
-		},
-		{
-			name:           "API key with extra characters",
-			apiKey:         suite.validAPIKey + "extra",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject API key with extra characters",
-		},
-		{
-			name:           "API key with prefix removed",
-			apiKey:         suite.validAPIKey[5:],
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject partial API key",
-		},
-		{
-			name:           "Empty string API key",
-			apiKey:         "",
-			endpoint:       "/api/cache-stats",
-			method:         "GET",
-			body:           nil,
-			expectedStatus: 401,
-			description:    "Should reject empty API key",
-		},
-		// Null byte test removed - FastHTTP rejects invalid headers before they reach the middleware
-		{
-			name:           "Unicode characters in API key",
-			apiKey:         suite.validAPIKey + "тест",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test reason"},
-			expectedStatus: 401,
-			description:    "Should reject API key with unicode characters",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			var req *http.Request
-			var err error
-
-			if tt.body != nil {
-				bodyBytes, _ := json.Marshal(tt.body)
-				req, err = http.NewRequest(tt.method, tt.endpoint, bytes.NewBuffer(bodyBytes))
-				suite.NoError(err)
-				req.Header.Set("Content-Type", "application/json")
-			} else {
-				req, err = http.NewRequest(tt.method, tt.endpoint, nil)
-				suite.NoError(err)
-			}
-
-			if tt.apiKey != "" {
-				req.Header.Set("X-API-Key", tt.apiKey)
-			}
-
-			resp, err := suite.app.Test(req)
-			suite.NoError(err, "Request should not error: %s", tt.description)
-
-			suite.Equal(tt.expectedStatus, resp.StatusCode,
-				"Status code mismatch for %s: %s", tt.name, tt.description)
-
-			// Verify response structure for unauthorized requests
-			if tt.expectedStatus == 401 {
-				body, err := io.ReadAll(resp.Body)
-				suite.NoError(err)
-
-				var response map[string]interface{}
-				err = json.Unmarshal(body, &response)
-				suite.NoError(err)
-
-				suite.Contains(response, "error", "Unauthorized response should contain error field")
-				suite.Equal("Unauthorized", response["error"], "Should return 'Unauthorized' message")
-			}
-		})
-	}
-}
-
-// TestAPIAuthenticationWithoutConfiguredKey tests behavior when no API key is configured
-func (suite *APIAuthSecurityTestSuite) TestAPIAuthenticationWithoutConfiguredKey() {
-	// Remove API key from environment
-	os.Unsetenv("GMP_ADMIN_API_KEY")
-	os.Unsetenv("ADMIN_API_KEY")
-
-	// Create new app without configured API key
-	app := fiber.New(fiber.Config{DisableStartupMessage: true})
-	api := app.Group("/api")
-	api.Use(authMiddleware)
-	api.Post("/user-ban", apiBanUser)
-
-	req, err := http.NewRequest("POST", "/api/user-ban",
-		bytes.NewBuffer([]byte(`{"user_id": "test", "reason": "test"}`)))
-	suite.NoError(err)
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-API-Key", "any-key")
-
-	resp, err := app.Test(req)
-	suite.NoError(err)
-
-	suite.Equal(200, resp.StatusCode, "Should return 200 when API key not configured (auth disabled)")
-
-	body, err := io.ReadAll(resp.Body)
-	suite.NoError(err)
-
-	// When no API key is configured, auth is disabled and the request succeeds
-	suite.Equal("OK: user banned", string(body), "Should succeed when auth is disabled")
-}
-
-// TestTimingAttackResistance tests that the authentication is resistant to timing attacks
-func (suite *APIAuthSecurityTestSuite) TestTimingAttackResistance() {
-	// Set API key to enable authentication
-	os.Setenv("GMP_ADMIN_API_KEY", suite.validAPIKey)
-	defer os.Unsetenv("GMP_ADMIN_API_KEY")
-
-	// Test various invalid keys to ensure constant-time comparison
-	invalidKeys := []string{
-		"a",                      // Very short
-		"ab",                     // Short
-		"invalid-key",            // Different length
-		suite.validAPIKey[:10],   // Prefix match
-		suite.validAPIKey + "x",  // Almost correct
-		strings.Repeat("a", 100), // Very long
-		"",                       // Empty
-	}
-
-	timings := make([]time.Duration, len(invalidKeys))
-
-	for i, key := range invalidKeys {
-		start := time.Now()
-
-		req, err := http.NewRequest("POST", "/api/user-ban",
-			bytes.NewBuffer([]byte(`{"user_id": "test", "reason": "test"}`)))
-		suite.NoError(err)
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("X-API-Key", key)
-
-		resp, err := suite.app.Test(req)
-		suite.NoError(err)
-
-		timings[i] = time.Since(start)
-
-		suite.Equal(401, resp.StatusCode,
-			"All invalid keys should return 401, key: %s", key)
-	}
-
-	// Verify that timing variations are minimal (within reasonable bounds)
-	// This is a heuristic test - timing attack resistance is primarily
-	// achieved by the subtle.ConstantTimeCompare function
-	var minTime, maxTime time.Duration
-	for i, timing := range timings {
-		if i == 0 {
-			minTime = timing
-			maxTime = timing
-		} else {
-			if timing < minTime {
-				minTime = timing
-			}
-			if timing > maxTime {
-				maxTime = timing
-			}
-		}
-	}
-
-	// The timing difference should be reasonable (not orders of magnitude)
-	// This is mainly to catch obvious timing leaks
-	timingRatio := float64(maxTime) / float64(minTime)
-	suite.Less(timingRatio, 10.0,
-		"Timing difference should be reasonable (max/min < 10x)")
-}
-
-// TestConcurrentAPIAuthentication tests authentication under concurrent load
-func (suite *APIAuthSecurityTestSuite) TestConcurrentAPIAuthentication() {
-	// Set API key to enable authentication
-	os.Setenv("GMP_ADMIN_API_KEY", suite.validAPIKey)
-	defer os.Unsetenv("GMP_ADMIN_API_KEY")
-
-	const numGoroutines = 50
-	const numRequestsPerGoroutine = 10
-
-	var wg sync.WaitGroup
-	results := make(chan int, numGoroutines*numRequestsPerGoroutine)
-
-	// Test with mix of valid and invalid keys
-	testKeys := []string{
-		suite.validAPIKey, // Valid
-		"invalid-key-1",   // Invalid
-		"invalid-key-2",   // Invalid
-		suite.validAPIKey, // Valid
-		"",                // Empty
-	}
-
-	for i := 0; i < numGoroutines; i++ {
-		wg.Add(1)
-		go func(goroutineID int) {
-			defer wg.Done()
-
-			for j := 0; j < numRequestsPerGoroutine; j++ {
-				keyIndex := (goroutineID + j) % len(testKeys)
-				key := testKeys[keyIndex]
-
-				req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-				if err != nil {
-					results <- 500
-					continue
-				}
-
-				if key != "" {
-					req.Header.Set("X-API-Key", key)
-				}
-
-				resp, err := suite.app.Test(req)
-				if err != nil {
-					results <- 500
-					continue
-				}
-
-				results <- resp.StatusCode
-			}
-		}(i)
-	}
-
-	wg.Wait()
-	close(results)
-
-	// Collect and verify results
-	statusCounts := make(map[int]int)
-	for status := range results {
-		statusCounts[status]++
-	}
-
-	// Should have some 200s (valid keys) and some 401s (invalid keys)
-	suite.Greater(statusCounts[200], 0, "Should have successful requests with valid API key")
-	suite.Greater(statusCounts[401], 0, "Should have rejected requests with invalid API key")
-	suite.Equal(0, statusCounts[500], "Should not have internal server errors")
-}
-
-// TestAPIKeyEnvironmentVariablePrecedence tests the precedence of environment variables
-func (suite *APIAuthSecurityTestSuite) TestAPIKeyEnvironmentVariablePrecedence() {
-	prefixedKey := "prefixed-api-key"
-	unprefixedKey := "unprefixed-api-key"
-
-	// Test 1: Only GMP_ prefixed key is set
-	suite.Run("Only prefixed key set", func() {
-		os.Unsetenv("ADMIN_API_KEY")
-		os.Setenv("GMP_ADMIN_API_KEY", prefixedKey)
-		defer os.Unsetenv("GMP_ADMIN_API_KEY")
-
-		req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-		suite.NoError(err)
-		req.Header.Set("X-API-Key", prefixedKey)
-
-		resp, err := suite.app.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode, "Should accept prefixed API key")
-	})
-
-	// Test 2: Only unprefixed key is set
-	suite.Run("Only unprefixed key set", func() {
-		os.Unsetenv("GMP_ADMIN_API_KEY")
-		os.Setenv("ADMIN_API_KEY", unprefixedKey)
-		defer os.Unsetenv("ADMIN_API_KEY")
-
-		req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-		suite.NoError(err)
-		req.Header.Set("X-API-Key", unprefixedKey)
-
-		resp, err := suite.app.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode, "Should accept unprefixed API key when prefixed not available")
-	})
-
-	// Test 3: Both keys set - prefixed should take precedence
-	suite.Run("Both keys set - precedence", func() {
-		os.Setenv("GMP_ADMIN_API_KEY", prefixedKey)
-		os.Setenv("ADMIN_API_KEY", unprefixedKey)
-		defer func() {
-			os.Unsetenv("GMP_ADMIN_API_KEY")
-			os.Unsetenv("ADMIN_API_KEY")
-		}()
-
-		// Should accept prefixed key
-		req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-		suite.NoError(err)
-		req.Header.Set("X-API-Key", prefixedKey)
-
-		resp, err := suite.app.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode, "Should accept prefixed API key")
-
-		// Should reject unprefixed key when prefixed is available
-		req, err = http.NewRequest("GET", "/api/cache-stats", nil)
-		suite.NoError(err)
-		req.Header.Set("X-API-Key", unprefixedKey)
-
-		resp, err = suite.app.Test(req)
-		suite.NoError(err)
-		suite.Equal(401, resp.StatusCode, "Should reject unprefixed key when prefixed is configured")
-	})
-}
-
-// TestAPIAuthenticationErrorMessages tests that error messages don't leak information
-func (suite *APIAuthSecurityTestSuite) TestAPIAuthenticationErrorMessages() {
-	// Set API key to enable authentication
-	os.Setenv("GMP_ADMIN_API_KEY", suite.validAPIKey)
-	defer os.Unsetenv("GMP_ADMIN_API_KEY")
-
-	maliciousInputs := []string{
-		"admin",
-		"password",
-		"secret",
-		"' OR 1=1 --",
-		"<script>alert(1)</script>",
-		suite.validAPIKey + "almost",
-	}
-
-	for _, input := range maliciousInputs {
-		suite.Run(fmt.Sprintf("Error message for input: %s", input), func() {
-			req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-			suite.NoError(err)
-			req.Header.Set("X-API-Key", input)
-
-			resp, err := suite.app.Test(req)
-			suite.NoError(err)
-			suite.Equal(401, resp.StatusCode)
-
-			body, err := io.ReadAll(resp.Body)
-			suite.NoError(err)
-
-			var response map[string]interface{}
-			err = json.Unmarshal(body, &response)
-			suite.NoError(err)
-
-			errorMsg := strings.ToLower(response["error"].(string))
-
-			// Error message should not leak sensitive information
-			suite.NotContains(errorMsg, "key", "Error should not mention 'key'")
-			suite.NotContains(errorMsg, "password", "Error should not mention 'password'")
-			suite.NotContains(errorMsg, "secret", "Error should not mention 'secret'")
-			suite.NotContains(errorMsg, "admin", "Error should not mention 'admin'")
-			suite.NotContains(errorMsg, "expected", "Error should not mention expected values")
-			suite.NotContains(errorMsg, "correct", "Error should not mention correct values")
-
-			// Should be a generic unauthorized message
-			suite.Equal("unauthorized", errorMsg, "Should return generic unauthorized message")
-		})
-	}
-}
-
-// TestAPIAuthenticationHeaderVariations tests different header case variations
-func (suite *APIAuthSecurityTestSuite) TestAPIAuthenticationHeaderVariations() {
-	headerVariations := []string{
-		"X-API-Key", // Standard
-		"x-api-key", // Lowercase
-		"X-Api-Key", // Mixed case
-		"X-API-KEY", // Uppercase
-		"x-API-key", // Mixed case 2
-	}
-
-	for _, header := range headerVariations {
-		suite.Run(fmt.Sprintf("Header variation: %s", header), func() {
-			req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-			suite.NoError(err)
-			req.Header.Set(header, suite.validAPIKey)
-
-			resp, err := suite.app.Test(req)
-			suite.NoError(err)
-
-			// Fiber should handle header case insensitivity
-			// All variations should work
-			suite.Equal(200, resp.StatusCode,
-				"Header %s should be accepted (case insensitive)", header)
-		})
-	}
-}
-
-// BenchmarkAPIAuthentication benchmarks the authentication middleware performance
-func BenchmarkAPIAuthentication(b *testing.B) {
-	// Setup
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New()
-
-	validAPIKey := "benchmark-api-key"
-	os.Setenv("GMP_ADMIN_API_KEY", validAPIKey)
-	defer os.Unsetenv("GMP_ADMIN_API_KEY")
-
-	app := fiber.New(fiber.Config{DisableStartupMessage: true})
-	api := app.Group("/api")
-	api.Use(authMiddleware)
-	api.Get("/cache-stats", apiCacheStats)
-
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		req, _ := http.NewRequest("GET", "/api/cache-stats", nil)
-		req.Header.Set("X-API-Key", validAPIKey)
-
-		resp, _ := app.Test(req)
-		resp.Body.Close()
-	}
-}

api_test.go

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

backend_health.go

@@ -1,308 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/valyala/fasthttp"
-)
-
-// BackendHealthManager manages backend health and connection readiness
-type BackendHealthManager struct {
-	lastHealthCheck  time.Time
-	ctx              context.Context
-	client           *fasthttp.Client
-	readinessChan    chan bool
-	logger           *libpack_logger.Logger
-	cancel           context.CancelFunc
-	backendURL       string
-	checkInterval    time.Duration
-	maxRetries       int
-	mu               sync.RWMutex
-	consecutiveFails atomic.Int32
-	isHealthy        atomic.Bool
-	startupProbe     bool
-}
-
-// NewBackendHealthManager creates a new backend health manager
-func NewBackendHealthManager(client *fasthttp.Client, backendURL string, logger *libpack_logger.Logger) *BackendHealthManager {
-	ctx, cancel := context.WithCancel(context.Background())
-	return &BackendHealthManager{
-		client:        client,
-		backendURL:    backendURL,
-		checkInterval: 5 * time.Second,
-		maxRetries:    30, // 30 * 5s = 2.5 minutes max startup wait
-		ctx:           ctx,
-		cancel:        cancel,
-		logger:        logger,
-		startupProbe:  true,
-		readinessChan: make(chan bool, 1),
-	}
-}
-
-// WaitForBackendReady performs startup readiness probe
-func (bhm *BackendHealthManager) WaitForBackendReady(timeout time.Duration) error {
-	deadline := time.Now().Add(timeout)
-	retryCount := 0
-	initialDelay := 2 * time.Second
-	maxDelay := 30 * time.Second
-	currentDelay := initialDelay
-
-	bhm.logger.Info(&libpack_logger.LogMessage{
-		Message: "Waiting for GraphQL backend to become ready",
-		Pairs: map[string]interface{}{
-			"backend_url": bhm.backendURL,
-			"timeout":     timeout.String(),
-		},
-	})
-
-	for time.Now().Before(deadline) {
-		if bhm.checkBackendHealth() {
-			bhm.isHealthy.Store(true)
-			bhm.mu.Lock()
-			bhm.startupProbe = false
-			bhm.mu.Unlock()
-			bhm.logger.Info(&libpack_logger.LogMessage{
-				Message: "GraphQL backend is ready",
-				Pairs: map[string]interface{}{
-					"retry_count": retryCount,
-					"time_taken":  time.Since(deadline.Add(-timeout)).String(),
-				},
-			})
-			close(bhm.readinessChan)
-			return nil
-		}
-
-		retryCount++
-		if retryCount%5 == 0 {
-			bhm.logger.Warning(&libpack_logger.LogMessage{
-				Message: "Still waiting for GraphQL backend",
-				Pairs: map[string]interface{}{
-					"retry_count":    retryCount,
-					"time_remaining": time.Until(deadline).String(),
-				},
-			})
-		}
-
-		// Exponential backoff with jitter
-		time.Sleep(currentDelay)
-		currentDelay = time.Duration(float64(currentDelay) * 1.5)
-		if currentDelay > maxDelay {
-			currentDelay = maxDelay
-		}
-	}
-
-	return fmt.Errorf("GraphQL backend did not become ready within %v", timeout)
-}
-
-// StartHealthChecking starts periodic health checking
-func (bhm *BackendHealthManager) StartHealthChecking() {
-	if bhm == nil {
-		return
-	}
-	go func() {
-		// Wait for startup probe to complete
-		bhm.mu.RLock()
-		isStartupProbe := bhm.startupProbe
-		bhm.mu.RUnlock()
-
-		if isStartupProbe {
-			select {
-			case <-bhm.readinessChan:
-				// Backend is ready, proceed with health checks
-			case <-bhm.ctx.Done():
-				return
-			}
-		}
-
-		ticker := time.NewTicker(bhm.checkInterval)
-		defer ticker.Stop()
-
-		for {
-			select {
-			case <-bhm.ctx.Done():
-				return
-			case <-ticker.C:
-				isHealthy := bhm.checkBackendHealth()
-				bhm.updateHealthStatus(isHealthy)
-			}
-		}
-	}()
-}
-
-// checkBackendHealth performs a health check on the backend
-func (bhm *BackendHealthManager) checkBackendHealth() bool {
-	req := fasthttp.AcquireRequest()
-	resp := fasthttp.AcquireResponse()
-	defer fasthttp.ReleaseRequest(req)
-	defer fasthttp.ReleaseResponse(resp)
-
-	// Determine the health check URL
-	// If backendURL is just "http://host:port" or "http://host:port/", append /v1/graphql
-	// If it has a path like "/v1/graphql", use that path
-	healthCheckURL := bhm.backendURL
-	hasGraphQLPath := false
-
-	if len(bhm.backendURL) > 0 {
-		// Simple check: if URL has a path component beyond just "/"
-		lastSlash := -1
-		protoEnd := 0
-		if idx := strings.Index(bhm.backendURL, "://"); idx >= 0 {
-			protoEnd = idx + 3
-		}
-		for i := protoEnd; i < len(bhm.backendURL); i++ {
-			if bhm.backendURL[i] == '/' {
-				lastSlash = i
-				break
-			}
-		}
-		// Has path if there's a slash after protocol and it's not the last char or followed by more path
-		hasGraphQLPath = lastSlash >= protoEnd && lastSlash < len(bhm.backendURL)-1
-
-		// If no GraphQL path, append /v1/graphql (standard Hasura endpoint)
-		if !hasGraphQLPath {
-			// Remove trailing slash if present
-			baseURL := strings.TrimSuffix(bhm.backendURL, "/")
-			healthCheckURL = baseURL + "/v1/graphql"
-		}
-	}
-
-	// Always send GraphQL introspection query for health check
-	healthQuery := `{"query":"{__typename}"}`
-	req.SetRequestURI(healthCheckURL)
-	req.Header.SetMethod(http.MethodPost)
-	req.Header.SetContentType("application/json")
-	req.SetBody([]byte(healthQuery))
-
-	// Short timeout for health checks
-	err := bhm.client.DoTimeout(req, resp, 5*time.Second)
-	if err != nil {
-		bhm.logger.Debug(&libpack_logger.LogMessage{
-			Message: "Backend health check failed",
-			Pairs: map[string]interface{}{
-				"error":     err.Error(),
-				"check_url": healthCheckURL,
-			},
-		})
-		return false
-	}
-
-	statusCode := resp.StatusCode()
-	isHealthy := statusCode >= 200 && statusCode < 300
-
-	if !isHealthy {
-		bhm.logger.Debug(&libpack_logger.LogMessage{
-			Message: "Backend returned unhealthy status",
-			Pairs: map[string]interface{}{
-				"status_code": statusCode,
-				"check_url":   healthCheckURL,
-			},
-		})
-	}
-
-	return isHealthy
-}
-
-// updateHealthStatus updates the health status and logs state changes
-func (bhm *BackendHealthManager) updateHealthStatus(isHealthy bool) {
-	if bhm == nil || bhm.logger == nil {
-		return
-	}
-
-	bhm.mu.Lock()
-	bhm.lastHealthCheck = time.Now()
-	bhm.mu.Unlock()
-
-	previouslyHealthy := bhm.isHealthy.Load()
-	bhm.isHealthy.Store(isHealthy)
-
-	if isHealthy {
-		if !previouslyHealthy {
-			bhm.logger.Info(&libpack_logger.LogMessage{
-				Message: "GraphQL backend recovered",
-				Pairs: map[string]interface{}{
-					"consecutive_failures": bhm.consecutiveFails.Load(),
-				},
-			})
-			// Trigger circuit breaker reset if needed
-			if cfg != nil && cfg.CircuitBreaker.Enable && cb != nil {
-				// The circuit breaker will automatically reset based on its timeout
-			}
-		}
-		bhm.consecutiveFails.Store(0)
-	} else {
-		fails := bhm.consecutiveFails.Add(1)
-		if previouslyHealthy {
-			bhm.logger.Warning(&libpack_logger.LogMessage{
-				Message: "GraphQL backend became unhealthy",
-				Pairs: map[string]interface{}{
-					"consecutive_failures": fails,
-				},
-			})
-		}
-	}
-}
-
-// IsHealthy returns the current health status
-func (bhm *BackendHealthManager) IsHealthy() bool {
-	if bhm == nil {
-		return false
-	}
-	return bhm.isHealthy.Load()
-}
-
-// GetLastHealthCheck returns the last health check time
-func (bhm *BackendHealthManager) GetLastHealthCheck() time.Time {
-	if bhm == nil {
-		return time.Time{}
-	}
-	bhm.mu.RLock()
-	defer bhm.mu.RUnlock()
-	return bhm.lastHealthCheck
-}
-
-// GetConsecutiveFailures returns the number of consecutive health check failures
-func (bhm *BackendHealthManager) GetConsecutiveFailures() int32 {
-	if bhm == nil {
-		return 0
-	}
-	return bhm.consecutiveFails.Load()
-}
-
-// Shutdown gracefully shuts down the health manager
-func (bhm *BackendHealthManager) Shutdown() {
-	if bhm == nil {
-		return
-	}
-	bhm.cancel()
-	if bhm.logger != nil {
-		bhm.logger.Info(&libpack_logger.LogMessage{
-			Message: "Backend health manager shut down",
-		})
-	}
-}
-
-// Global backend health manager
-var (
-	backendHealthManager *BackendHealthManager
-	backendHealthOnce    sync.Once
-)
-
-// InitializeBackendHealth initializes the backend health manager
-func InitializeBackendHealth(client *fasthttp.Client, backendURL string, logger *libpack_logger.Logger) *BackendHealthManager {
-	backendHealthOnce.Do(func() {
-		backendHealthManager = NewBackendHealthManager(client, backendURL, logger)
-	})
-	return backendHealthManager
-}
-
-// GetBackendHealthManager returns the global backend health manager
-func GetBackendHealthManager() *BackendHealthManager {
-	return backendHealthManager
-}

buffer_pool.go

@@ -1,41 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-
-	"github.com/lukaszraczylo/graphql-monitoring-proxy/pkg/pools"
-)
-
-// Legacy compatibility layer - delegates to unified pool implementation
-
-// GetHTTPBuffer gets a buffer from the global pool
-func GetHTTPBuffer() *bytes.Buffer {
-	return pools.GetBuffer()
-}
-
-// PutHTTPBuffer returns a buffer to the global pool
-func PutHTTPBuffer(buf *bytes.Buffer) {
-	pools.PutBuffer(buf)
-}
-
-// GetGzipWriter gets a gzip writer from the global pool
-func GetGzipWriter(w io.Writer) *gzip.Writer {
-	return pools.GetGzipWriter(w)
-}
-
-// PutGzipWriter returns a gzip writer to the global pool
-func PutGzipWriter(gz *gzip.Writer) {
-	pools.PutGzipWriter(gz)
-}
-
-// GetGzipReader gets a gzip reader from the global pool
-func GetGzipReader(r io.Reader) (*gzip.Reader, error) {
-	return pools.GetGzipReader(r)
-}
-
-// PutGzipReader returns a gzip reader to the global pool
-func PutGzipReader(gr *gzip.Reader) {
-	pools.PutGzipReader(gr)
-}

cache/cache.go

@@ -3,7 +3,6 @@ package libpack_cache
 import (
 	"bytes"
 	"compress/gzip"
-	"fmt"
 	"io"
 	"sync/atomic"
 	"time"
@@ -24,14 +23,7 @@ type CacheConfig struct {
 		DB       int    `json:"db"`
 		Enable   bool   `json:"enable"`
 	}
-	Memory struct {
-		MaxMemorySize int64 `json:"max_memory_size"` // Maximum memory size in bytes
-		MaxEntries    int64 `json:"max_entries"`     // Maximum number of entries
-		UseLRU        bool  `json:"use_lru"`         // Use LRU eviction algorithm instead of random eviction
-	}
-	TTL                  int  `json:"ttl"`
-	IncludeUserContext   bool `json:"include_user_context"`    // Include user ID and role in cache key
-	PerUserCacheDisabled bool `json:"per_user_cache_disabled"` // Disable per-user caching (backward compatibility)
+	TTL int `json:"ttl"`
 }
 
 type CacheStats struct {
@@ -46,9 +38,6 @@ type CacheClient interface {
 	Delete(key string)
 	Clear()
 	CountQueries() int64
-	// Memory usage reporting methods
-	GetMemoryUsage() int64   // Returns current memory usage in bytes
-	GetMaxMemorySize() int64 // Returns max memory size in bytes
 }
 
 var (
@@ -56,45 +45,8 @@ var (
 	config     *CacheConfig
 )
 
-// CalculateHash generates an MD5 hash from the request body and optionally user context.
-// For GraphQL requests, this includes both the query and variables,
-// ensuring that identical queries with different variables are cached separately.
-//
-// SECURITY FIX: This function now includes user ID and role in the cache key by default
-// to prevent data leakage between authenticated users. Set CACHE_PER_USER_DISABLED=true
-// to revert to the old behavior (NOT RECOMMENDED for multi-user applications).
-//
-// Example GraphQL request body:
-//
-//	{
-//	  "query": "query GetUser($id: ID!) { user(id: $id) { name } }",
-//	  "variables": { "id": "123" }
-//	}
-//
-// With user context enabled (default):
-//   - Same query, same variables, same user → same cache key
-//   - Same query, same variables, different user → different cache key
-//
-// Different variable values will always produce different cache keys.
-func CalculateHash(c *fiber.Ctx, userID string, userRole string) string {
-	cacheKeyData := string(c.Body())
-
-	// Include user context in cache key (default behavior for security)
-	// Only skip if explicitly disabled via configuration (backward compatibility)
-	if config != nil && !config.PerUserCacheDisabled {
-		// Normalize empty user values to prevent cache key collisions
-		if userID == "" {
-			userID = "-"
-		}
-		if userRole == "" {
-			userRole = "-"
-		}
-
-		// Append user context to ensure cache isolation between users
-		cacheKeyData = fmt.Sprintf("%s|uid:%s|role:%s", cacheKeyData, userID, userRole)
-	}
-
-	return strutil.Md5(cacheKeyData)
+func CalculateHash(c *fiber.Ctx) string {
+	return strutil.Md5(c.Body())
 }
 
 func EnableCache(cfg *CacheConfig) {
@@ -109,58 +61,16 @@ func EnableCache(cfg *CacheConfig) {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Using Redis cache",
 		})
-		redisClient, err := libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
+		cfg.Client = libpack_cache_redis.New(&libpack_cache_redis.RedisClientConfig{
 			RedisDB:       cfg.Redis.DB,
 			RedisServer:   cfg.Redis.URL,
 			RedisPassword: cfg.Redis.Password,
 		})
-		if err != nil {
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to create Redis client",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-			// Fall back to memory cache
-			cfg.Client = libpack_cache_memory.New(time.Duration(cfg.TTL) * time.Second)
-		} else {
-			cfg.Client = libpack_cache_redis.NewCacheWrapper(redisClient, cfg.Logger)
-		}
 	} else {
-		// Calculate memory and entry limits
-		maxMemory := cfg.Memory.MaxMemorySize
-		if maxMemory <= 0 {
-			maxMemory = libpack_cache_memory.DefaultMaxMemorySize
-		}
-
-		maxEntries := cfg.Memory.MaxEntries
-		if maxEntries <= 0 {
-			maxEntries = libpack_cache_memory.DefaultMaxCacheSize
-		}
-
-		cacheType := "standard"
-		if cfg.Memory.UseLRU {
-			cacheType = "LRU"
-		}
-
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Using in-memory cache",
-			Pairs: map[string]interface{}{
-				"type":                  cacheType,
-				"max_memory_size_bytes": maxMemory,
-				"max_entries":           maxEntries,
-			},
 		})
-
-		if cfg.Memory.UseLRU {
-			// Use LRU cache with proper eviction algorithm
-			cfg.Client = libpack_cache_memory.NewLRUMemoryCache(maxMemory, maxEntries)
-		} else {
-			// Use standard sync.Map-based cache
-			cfg.Client = libpack_cache_memory.NewWithSize(
-				time.Duration(cfg.TTL)*time.Second,
-				maxMemory,
-				maxEntries,
-			)
-		}
+		cfg.Client = libpack_cache_memory.New(time.Duration(cfg.TTL) * time.Second)
 	}
 	config = cfg
 }
@@ -183,15 +93,7 @@ func CacheLookup(hash string) []byte {
 				})
 				return nil
 			}
-			// Ensure reader is always closed, even on error
-			defer func() {
-				if closeErr := reader.Close(); closeErr != nil {
-					config.Logger.Error(&libpack_logger.LogMessage{
-						Message: "Failed to close gzip reader",
-						Pairs:   map[string]interface{}{"error": closeErr.Error(), "hash": hash},
-					})
-				}
-			}()
+			defer reader.Close()
 
 			decompressed, err := io.ReadAll(reader)
 			if err != nil {
@@ -217,17 +119,7 @@ func CacheDelete(hash string) {
 		Message: "Deleting data from cache",
 		Pairs:   map[string]interface{}{"hash": hash},
 	})
-	// Use atomic operations with validation to prevent inconsistent statistics
-	for {
-		current := atomic.LoadInt64(&cacheStats.CachedQueries)
-		if current <= 0 {
-			break // Don't go below zero
-		}
-		if atomic.CompareAndSwapInt64(&cacheStats.CachedQueries, current, current-1) {
-			break
-		}
-		// Retry if CAS failed due to concurrent modification
-	}
+	atomic.AddInt64(&cacheStats.CachedQueries, -1)
 	config.Client.Delete(hash)
 }
 
@@ -269,9 +161,6 @@ func CacheGetQueries() int64 {
 }
 
 func CacheClear() {
-	if !IsCacheInitialized() {
-		return
-	}
 	config.Client.Clear()
 	cacheStats = &CacheStats{}
 }
@@ -283,28 +172,8 @@ func GetCacheStats() *CacheStats {
 	config.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Getting cache stats",
 	})
-	// Return a copy to avoid race conditions
-	return &CacheStats{
-		CacheHits:     atomic.LoadInt64(&cacheStats.CacheHits),
-		CacheMisses:   atomic.LoadInt64(&cacheStats.CacheMisses),
-		CachedQueries: CacheGetQueries(),
-	}
-}
-
-// GetCacheMemoryUsage returns the current memory usage of the cache in bytes
-func GetCacheMemoryUsage() int64 {
-	if !IsCacheInitialized() {
-		return 0
-	}
-	return config.Client.GetMemoryUsage()
-}
-
-// GetCacheMaxMemorySize returns the maximum memory size allowed for the cache in bytes
-func GetCacheMaxMemorySize() int64 {
-	if !IsCacheInitialized() {
-		return 0
-	}
-	return config.Client.GetMaxMemorySize()
+	cacheStats.CachedQueries = CacheGetQueries()
+	return cacheStats
 }
 
 func ShouldUseRedisCache(cfg *CacheConfig) bool {

cache/cache_additional_test.go

@@ -1,459 +0,0 @@
-package libpack_cache
-
-import (
-	"bytes"
-	"compress/gzip"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	libpack_cache_memory "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/valyala/fasthttp"
-)
-
-func (suite *Tests) Test_CalculateHash() {
-	// Setup
-	app := fiber.New()
-	ctx := app.AcquireCtx(&fasthttp.RequestCtx{})
-	defer app.ReleaseCtx(ctx)
-
-	// Test with empty body
-	suite.Run("empty body", func() {
-		ctx.Request().SetBody([]byte(""))
-		hash := CalculateHash(ctx, "user1", "admin")
-		assert.NotEmpty(hash)
-		assert.Equal(32, len(hash)) // MD5 hash is 32 characters
-	})
-
-	// Test with non-empty body
-	suite.Run("non-empty body", func() {
-		ctx.Request().SetBody([]byte("test body"))
-		hash := CalculateHash(ctx, "user1", "admin")
-		assert.NotEmpty(hash)
-		assert.Equal(32, len(hash))
-	})
-
-	// Test with different bodies produce different hashes
-	suite.Run("different bodies", func() {
-		ctx.Request().SetBody([]byte("body1"))
-		hash1 := CalculateHash(ctx, "user1", "admin")
-
-		ctx.Request().SetBody([]byte("body2"))
-		hash2 := CalculateHash(ctx, "user1", "admin")
-
-		assert.NotEqual(hash1, hash2)
-	})
-
-	// Test with GraphQL query and variables
-	suite.Run("graphql with same query different variables", func() {
-		// Same query, different variables should produce different hashes
-		query1 := []byte(`{"query":"query GetUser($id: ID!) { user(id: $id) { name } }","variables":{"id":"123"}}`)
-		query2 := []byte(`{"query":"query GetUser($id: ID!) { user(id: $id) { name } }","variables":{"id":"456"}}`)
-
-		ctx.Request().SetBody(query1)
-		hash1 := CalculateHash(ctx, "user1", "admin")
-
-		ctx.Request().SetBody(query2)
-		hash2 := CalculateHash(ctx, "user1", "admin")
-
-		assert.NotEqual(hash1, hash2, "Different variables should produce different cache keys")
-	})
-
-	// Test with GraphQL query without variables
-	suite.Run("graphql with and without variables", func() {
-		// Same query with and without variables should produce different hashes
-		query1 := []byte(`{"query":"query GetUsers { users { name } }"}`)
-		query2 := []byte(`{"query":"query GetUsers { users { name } }","variables":{}}`)
-
-		ctx.Request().SetBody(query1)
-		hash1 := CalculateHash(ctx, "user1", "admin")
-
-		ctx.Request().SetBody(query2)
-		hash2 := CalculateHash(ctx, "user1", "admin")
-
-		assert.NotEqual(hash1, hash2, "Query with and without variables object should produce different cache keys")
-	})
-
-	// SECURITY TEST: Different users should get different cache keys
-	suite.Run("different users produce different cache keys", func() {
-		// Same query, same variables, but different users - CRITICAL SECURITY TEST
-		query := []byte(`{"query":"query GetMyProfile { me { id email } }"}`)
-		ctx.Request().SetBody(query)
-
-		hash1 := CalculateHash(ctx, "user1", "admin")
-		hash2 := CalculateHash(ctx, "user2", "user")
-
-		assert.NotEqual(hash1, hash2, "Different users MUST produce different cache keys to prevent data leakage")
-	})
-
-	// SECURITY TEST: Same user should get same cache key
-	suite.Run("same user produces same cache key", func() {
-		// Same query, same user
-		query := []byte(`{"query":"query GetMyProfile { me { id email } }"}`)
-		ctx.Request().SetBody(query)
-
-		hash1 := CalculateHash(ctx, "user1", "admin")
-		hash2 := CalculateHash(ctx, "user1", "admin")
-
-		assert.Equal(hash1, hash2, "Same user should get same cache key for cache effectiveness")
-	})
-
-	// SECURITY TEST: Different roles should get different cache keys
-	suite.Run("different roles produce different cache keys", func() {
-		// Same query, same user ID, but different roles
-		query := []byte(`{"query":"query GetData { data { value } }"}`)
-		ctx.Request().SetBody(query)
-
-		hash1 := CalculateHash(ctx, "user1", "admin")
-		hash2 := CalculateHash(ctx, "user1", "user")
-
-		assert.NotEqual(hash1, hash2, "Different roles MUST produce different cache keys to prevent privilege escalation")
-	})
-
-	// SECURITY TEST: Empty user context should be normalized
-	suite.Run("empty user context is normalized", func() {
-		query := []byte(`{"query":"query GetPublic { public { data } }"}`)
-		ctx.Request().SetBody(query)
-
-		// Empty strings should be normalized to "-"
-		hash1 := CalculateHash(ctx, "", "")
-		hash2 := CalculateHash(ctx, "-", "-")
-
-		assert.Equal(hash1, hash2, "Empty user context should be normalized to prevent cache key collisions")
-	})
-
-	// BACKWARD COMPATIBILITY TEST: Legacy mode without user context
-	suite.Run("legacy mode without user context", func() {
-		// Setup config with per-user cache disabled
-		oldConfig := config
-		config = &CacheConfig{
-			Logger:               libpack_logger.New(),
-			Client:               libpack_cache_memory.New(5 * time.Minute),
-			TTL:                  60,
-			PerUserCacheDisabled: true, // Disable per-user caching
-		}
-		defer func() { config = oldConfig }()
-
-		query := []byte(`{"query":"query GetData { data { value } }"}`)
-		ctx.Request().SetBody(query)
-
-		// In legacy mode, different users should get the SAME cache key (backward compatibility)
-		hash1 := CalculateHash(ctx, "user1", "admin")
-		hash2 := CalculateHash(ctx, "user2", "user")
-
-		assert.Equal(hash1, hash2, "With per-user cache disabled, all users get same cache key (backward compatibility)")
-	})
-}
-
-func (suite *Tests) Test_CacheDelete() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test deleting a cache entry
-	suite.Run("delete existing entry", func() {
-		// Add an entry to cache
-		testKey := "test-delete-key"
-		testValue := []byte("test-delete-value")
-		CacheStore(testKey, testValue)
-
-		// Verify it was added
-		result := CacheLookup(testKey)
-		assert.Equal(testValue, result)
-
-		// Delete the entry
-		CacheDelete(testKey)
-
-		// Verify it was deleted
-		result = CacheLookup(testKey)
-		assert.Nil(result)
-	})
-
-	// Test deleting a non-existent entry
-	suite.Run("delete non-existent entry", func() {
-		// This should not cause any errors
-		CacheDelete("non-existent-key")
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-		config = nil
-
-		// This should not cause any errors
-		CacheDelete("any-key")
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheStoreWithTTL() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test storing with custom TTL
-	suite.Run("store with custom TTL", func() {
-		testKey := "test-ttl-key"
-		testValue := []byte("test-ttl-value")
-		customTTL := 1 * time.Second
-
-		CacheStoreWithTTL(testKey, testValue, customTTL)
-
-		// Verify it was stored
-		result := CacheLookup(testKey)
-		assert.Equal(testValue, result)
-
-		// Wait for TTL to expire
-		time.Sleep(1100 * time.Millisecond)
-
-		// Verify it was removed
-		result = CacheLookup(testKey)
-		assert.Nil(result)
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-		config = nil
-
-		// This should not cause any errors
-		CacheStoreWithTTL("any-key", []byte("any-value"), 1*time.Second)
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheGetQueries() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test getting query count
-	suite.Run("get query count", func() {
-		// Clear cache
-		CacheClear()
-
-		// Add some entries
-		CacheStore("test-key-1", []byte("test-value-1"))
-		CacheStore("test-key-2", []byte("test-value-2"))
-
-		// Get query count
-		count := CacheGetQueries()
-		assert.Equal(int64(2), count)
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-		config = nil
-
-		// This should return 0
-		count := CacheGetQueries()
-		assert.Equal(int64(0), count)
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheClear() {
-	// Setup a new cache for this test to avoid interference
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Create a new CacheStats instance
-	cacheStats = &CacheStats{
-		CachedQueries: 0,
-		CacheHits:     0,
-		CacheMisses:   0,
-	}
-
-	// Test clearing cache
-	suite.Run("clear cache", func() {
-		// Add some entries
-		CacheStore("test-key-1", []byte("test-value-1"))
-		CacheStore("test-key-2", []byte("test-value-2"))
-
-		// Verify they were added
-		assert.NotNil(CacheLookup("test-key-1"))
-		assert.NotNil(CacheLookup("test-key-2"))
-
-		// Get the current stats before clearing
-		beforeStats := GetCacheStats()
-
-		// Clear cache
-		CacheClear()
-
-		// Verify cache was cleared
-		assert.Nil(CacheLookup("test-key-1"))
-		assert.Nil(CacheLookup("test-key-2"))
-
-		// Verify stats were reset
-		afterStats := GetCacheStats()
-		assert.Equal(int64(0), afterStats.CachedQueries)
-		assert.Less(afterStats.CachedQueries, beforeStats.CachedQueries)
-	})
-}
-
-func (suite *Tests) Test_GetCacheStats() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-	cacheStats = &CacheStats{}
-
-	// Test getting cache stats
-	suite.Run("get cache stats", func() {
-		// Clear cache
-		CacheClear()
-
-		// Add some entries and perform lookups
-		CacheStore("test-key-1", []byte("test-value-1"))
-		CacheStore("test-key-2", []byte("test-value-2"))
-		CacheLookup("test-key-1") // Hit
-		CacheLookup("test-key-3") // Miss
-
-		// Get stats
-		stats := GetCacheStats()
-		assert.Equal(int64(2), stats.CachedQueries)
-		assert.Equal(int64(1), stats.CacheHits)
-		assert.Equal(int64(1), stats.CacheMisses)
-	})
-
-	// Test with uninitialized cache
-	suite.Run("uninitialized cache", func() {
-		// Save current config
-		oldConfig := config
-		config = nil
-
-		// This should return empty stats
-		stats := GetCacheStats()
-		assert.Equal(int64(0), stats.CachedQueries)
-		assert.Equal(int64(0), stats.CacheHits)
-		assert.Equal(int64(0), stats.CacheMisses)
-
-		// Restore config
-		config = oldConfig
-	})
-}
-
-func (suite *Tests) Test_CacheLookup_Compressed() {
-	// Setup
-	config = &CacheConfig{
-		Logger: libpack_logger.New(),
-		Client: libpack_cache_memory.New(5 * time.Minute),
-		TTL:    5,
-	}
-
-	// Test lookup with compressed data
-	suite.Run("lookup compressed data", func() {
-		testKey := "test-compressed-key"
-		testValue := []byte("test-compressed-value")
-
-		// Compress the data
-		var buf bytes.Buffer
-		gzWriter := gzip.NewWriter(&buf)
-		_, err := gzWriter.Write(testValue)
-		assert.NoError(err)
-		err = gzWriter.Close()
-		assert.NoError(err)
-		compressedData := buf.Bytes()
-
-		// Store compressed data directly
-		config.Client.Set(testKey, compressedData, time.Duration(config.TTL)*time.Second)
-
-		// Lookup should automatically decompress
-		result := CacheLookup(testKey)
-		assert.Equal(testValue, result)
-	})
-
-	// Skip the invalid compressed data test as it's causing issues
-	// We'll mock the behavior instead
-	suite.Run("lookup invalid compressed data", func() {
-		// Instead of testing with invalid data, we'll just verify
-		// that the function handles errors properly by checking
-		// the error handling code path is covered
-		assert.NotPanics(func() {
-			// This is just to ensure the test passes
-			// The actual implementation should handle invalid data gracefully
-		})
-	})
-}
-
-func (suite *Tests) Test_ShouldUseRedisCache() {
-	// Test with Redis enabled
-	suite.Run("redis enabled", func() {
-		cfg := &CacheConfig{}
-		cfg.Redis.Enable = true
-
-		result := ShouldUseRedisCache(cfg)
-		assert.True(result)
-	})
-
-	// Test with Redis disabled
-	suite.Run("redis disabled", func() {
-		cfg := &CacheConfig{}
-		cfg.Redis.Enable = false
-
-		result := ShouldUseRedisCache(cfg)
-		assert.False(result)
-	})
-}
-
-func (suite *Tests) Test_IsCacheInitialized() {
-	// Test with initialized cache
-	suite.Run("initialized cache", func() {
-		config = &CacheConfig{
-			Logger: libpack_logger.New(),
-			Client: libpack_cache_memory.New(5 * time.Minute),
-		}
-
-		result := IsCacheInitialized()
-		assert.True(result)
-	})
-
-	// Test with nil config
-	suite.Run("nil config", func() {
-		oldConfig := config
-		config = nil
-
-		result := IsCacheInitialized()
-		assert.False(result)
-
-		config = oldConfig
-	})
-
-	// Test with nil client
-	suite.Run("nil client", func() {
-		oldConfig := config
-		config = &CacheConfig{
-			Logger: libpack_logger.New(),
-			Client: nil,
-		}
-
-		result := IsCacheInitialized()
-		assert.False(result)
-
-		config = oldConfig
-	})
-}

cache/memory/buffer_pool.go

@@ -1,17 +0,0 @@
-package libpack_cache_memory
-
-import (
-	"bytes"
-
-	"github.com/lukaszraczylo/graphql-monitoring-proxy/pkg/pools"
-)
-
-// GetBuffer gets a buffer from the pool (delegates to unified implementation)
-func GetBuffer() *bytes.Buffer {
-	return pools.GetBuffer()
-}
-
-// PutBuffer returns a buffer to the pool (delegates to unified implementation)
-func PutBuffer(buf *bytes.Buffer) {
-	pools.PutBuffer(buf)
-}

cache/memory/compression_test.go

@@ -1,218 +0,0 @@
-package libpack_cache_memory
-
-import (
-	"bytes"
-	"compress/gzip"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// TestCompressionThreshold tests that values are only compressed when they exceed the threshold
-func TestCompressionThreshold(t *testing.T) {
-	cache := New(5 * time.Second)
-
-	// Create test values
-	smallValue := make([]byte, CompressionThreshold-100) // Below threshold
-	largeValue := make([]byte, CompressionThreshold*2)   // Above threshold
-
-	// Fill values with compressible data (repeating patterns compress well)
-	for i := 0; i < len(smallValue); i++ {
-		smallValue[i] = byte(i % 10)
-	}
-	for i := 0; i < len(largeValue); i++ {
-		largeValue[i] = byte(i % 10)
-	}
-
-	// Test small value
-	cache.Set("small-key", smallValue, 5*time.Second)
-
-	// Extract the entry directly from the cache to check if it's compressed
-	entryRaw, found := cache.entries.Load("small-key")
-	assert.True(t, found, "Entry should exist")
-
-	entry := entryRaw.(CacheEntry)
-	assert.False(t, entry.Compressed, "Small value should not be compressed")
-	assert.Equal(t, smallValue, entry.Value, "Small value should be stored as-is")
-
-	// Test large value
-	cache.Set("large-key", largeValue, 5*time.Second)
-
-	entryRaw, found = cache.entries.Load("large-key")
-	assert.True(t, found, "Entry should exist")
-
-	entry = entryRaw.(CacheEntry)
-	assert.True(t, entry.Compressed, "Large value should be compressed")
-
-	// Ensure the stored value isn't the original
-	assert.NotEqual(t, largeValue, entry.Value, "Large value should not be stored as-is")
-
-	// Verify the value is actually compressed (should be smaller)
-	assert.Less(t, len(entry.Value), len(largeValue), "Compressed value should be smaller than original")
-
-	// Verify we can retrieve the uncompressed value correctly
-	retrievedLarge, found := cache.Get("large-key")
-	assert.True(t, found, "Large value should be retrievable")
-	assert.Equal(t, largeValue, retrievedLarge, "Retrieved large value should match original")
-}
-
-// TestCompressionMemoryUsage tests that memory usage is calculated correctly for compressed entries
-func TestCompressionMemoryUsage(t *testing.T) {
-	cache := New(5 * time.Second)
-
-	// Create a large, highly compressible value
-	valueSize := CompressionThreshold * 4
-	value := make([]byte, valueSize)
-	for i := 0; i < valueSize; i++ {
-		value[i] = byte(i % 2) // Highly compressible pattern (alternating 0s and 1s)
-	}
-
-	// Get initial memory usage
-	initialMemUsage := cache.GetMemoryUsage()
-
-	// Add the value
-	key := "large-compressible-key"
-	cache.Set(key, value, 5*time.Second)
-
-	// Get memory usage after adding
-	newMemUsage := cache.GetMemoryUsage()
-
-	// The memory usage increase should be less than the full value size due to compression
-	memUsageIncrease := newMemUsage - initialMemUsage
-
-	// Extract the entry to check its compressed size
-	entryRaw, found := cache.entries.Load(key)
-	assert.True(t, found, "Entry should exist")
-
-	entry := entryRaw.(CacheEntry)
-	assert.True(t, entry.Compressed, "Value should be compressed")
-
-	// Verify the reported memory usage matches the compressed size + overheads
-	compressedSize := int64(len(entry.Value))
-	keySize := int64(len(key))
-	expectedUsage := compressedSize + keySize + approxEntryOverhead
-
-	// The memory usage should reflect the compressed size, not the original size
-	assert.InDelta(t, expectedUsage, memUsageIncrease, float64(approxEntryOverhead),
-		"Memory usage should be based on compressed size")
-
-	// Verify memory usage is correctly updated after deletion
-	cache.Delete(key)
-	finalMemUsage := cache.GetMemoryUsage()
-	assert.Equal(t, initialMemUsage, finalMemUsage,
-		"Memory usage should return to initial value after deletion")
-}
-
-// TestUncompressibleData tests the case where compression doesn't reduce size
-func TestUncompressibleData(t *testing.T) {
-	cache := New(5 * time.Second)
-
-	// Create a large, random (less compressible) value
-	valueSize := CompressionThreshold * 2
-
-	// Create pseudo-random data that doesn't compress well
-	// Using a custom PRNG for deterministic results across test runs
-	value := make([]byte, valueSize)
-	seed := uint32(42)
-	for i := 0; i < valueSize; i++ {
-		// Simple linear congruential generator
-		seed = seed*1664525 + 1013904223
-		value[i] = byte(seed)
-	}
-
-	// Try to compress it directly to see if it actually would reduce size
-	var buf bytes.Buffer
-	gw := gzip.NewWriter(&buf)
-	_, _ = gw.Write(value)
-	_ = gw.Close()
-	compressedDirectly := buf.Bytes()
-
-	// Now use the cache's Set method
-	key := "uncompressible-key"
-	cache.Set(key, value, 5*time.Second)
-
-	// Extract the entry to check if it's compressed
-	entryRaw, found := cache.entries.Load(key)
-	assert.True(t, found, "Entry should exist")
-
-	entry := entryRaw.(CacheEntry)
-
-	// If our test data actually compressed to a smaller size, we expect the cache to store it compressed
-	if len(compressedDirectly) < len(value) {
-		assert.True(t, entry.Compressed, "Value should be stored compressed if smaller")
-		assert.Less(t, len(entry.Value), len(value), "Compressed value should be smaller")
-	} else {
-		// Uncommon case: our pseudo-random data actually expanded with gzip
-		// In this case, the cache should store it uncompressed
-		assert.False(t, entry.Compressed, "Value should not be compressed if it would expand")
-		assert.Equal(t, value, entry.Value, "Value should be stored as-is")
-	}
-
-	// Regardless, we should be able to get the correct value back
-	retrievedValue, found := cache.Get(key)
-	assert.True(t, found, "Value should be retrievable")
-	assert.Equal(t, value, retrievedValue, "Retrieved value should match original")
-}
-
-// TestCompressDecompressDirectly tests the compress and decompress methods directly
-func TestCompressDecompressDirectly(t *testing.T) {
-	cache := New(5 * time.Second)
-
-	// Test with various sizes
-	testSizes := []int{
-		100,                      // Small
-		CompressionThreshold - 1, // Just below threshold
-		CompressionThreshold,     // At threshold
-		CompressionThreshold + 1, // Just above threshold
-		CompressionThreshold * 2, // Well above threshold
-	}
-
-	for _, size := range testSizes {
-		t.Run("Size-"+string(rune('A'+len(testSizes)%26)), func(t *testing.T) {
-			// Generate test data with a repeating pattern
-			data := make([]byte, size)
-			for i := 0; i < size; i++ {
-				data[i] = byte(i % 256)
-			}
-
-			// Compress the data
-			compressed, err := cache.compress(data)
-			assert.NoError(t, err, "Compression should not error")
-
-			// Small data may get larger when compressed, larger data should get smaller
-			if size > CompressionThreshold {
-				assert.Less(t, len(compressed), len(data),
-					"Compression should reduce size for data above threshold")
-			}
-
-			// Decompress and verify it matches the original
-			decompressed, err := cache.decompress(compressed)
-			assert.NoError(t, err, "Decompression should not error")
-			assert.Equal(t, data, decompressed, "Data should round-trip correctly through compression")
-		})
-	}
-}
-
-// TestDecompressInvalidData tests handling invalid data in decompress
-func TestDecompressInvalidData(t *testing.T) {
-	cache := New(5 * time.Second)
-
-	// Try to decompress non-gzip data
-	invalidData := []byte("This is not valid gzip data")
-	_, err := cache.decompress(invalidData)
-	assert.Error(t, err, "Decompressing invalid data should return error")
-
-	// Set compressed flag but store invalid data
-	key := "invalid-compressed-key"
-	cache.entries.Store(key, CacheEntry{
-		Value:      invalidData,
-		ExpiresAt:  time.Now().Add(5 * time.Second),
-		Compressed: true, // Flag as compressed even though it's not
-		MemorySize: int64(len(invalidData) + len(key) + approxEntryOverhead),
-	})
-
-	// Try to get it - should fail gracefully
-	_, found := cache.Get(key)
-	assert.False(t, found, "Get should fail gracefully for invalid compressed data")
-}

cache/memory/eviction_test.go

@@ -1,185 +0,0 @@
-package libpack_cache_memory
-
-import (
-	"fmt"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-)
-
-// TestEvictToFreeMemory tests that the cache correctly evicts
-// items when it exceeds its memory limit.
-func TestEvictToFreeMemory(t *testing.T) {
-	// Create a cache with a small memory limit: 5KB (ensure eviction happens)
-	smallMemLimit := int64(5 * 1024)
-	cache := NewWithSize(5*time.Second, smallMemLimit, 1000)
-
-	// Create entries with known sizes
-	// Each entry will be ~512 bytes plus overhead
-	valueSize := 512
-	numEntriesToExceedLimit := 12 // Should exceed the 5KB limit and force eviction
-
-	// Create a slice to track keys in insertion order
-	keys := make([]string, numEntriesToExceedLimit)
-
-	// Add entries with significant delays between insertions
-	for i := 0; i < numEntriesToExceedLimit; i++ {
-		key := fmt.Sprintf("test-key-%d", i)
-		keys[i] = key
-
-		value := make([]byte, valueSize)
-		for j := 0; j < valueSize; j++ {
-			value[j] = byte(i % 256) // Fill with a repeating pattern
-		}
-
-		cache.Set(key, value, 30*time.Second)
-
-		// More significant delay to ensure different timestamps
-		time.Sleep(10 * time.Millisecond)
-	}
-
-	// Allow time for eviction to complete
-	time.Sleep(50 * time.Millisecond)
-
-	// Verify memory usage is below the limit
-	memUsage := cache.GetMemoryUsage()
-	assert.LessOrEqual(t, memUsage, smallMemLimit,
-		"Memory usage (%d) should be less than or equal to the limit (%d)", memUsage, smallMemLimit)
-
-	// Count how many items are left in the cache and which ones
-	present := 0
-	for i := 0; i < numEntriesToExceedLimit; i++ {
-		_, found := cache.Get(keys[i])
-		if found {
-			present++
-		}
-	}
-
-	// We expect some items to be evicted based on the memory limit
-	assert.Less(t, present, numEntriesToExceedLimit,
-		"Some items should have been evicted (%d present out of %d total)",
-		present, numEntriesToExceedLimit)
-
-	// Verify newer items (inserted later) are more likely to be in the cache
-	// Check the last few items which should be the newest
-	for i := numEntriesToExceedLimit - 3; i < numEntriesToExceedLimit; i++ {
-		_, found := cache.Get(keys[i])
-		assert.True(t, found, "Newer key %s should still exist", keys[i])
-	}
-}
-
-// TestMaxCacheSize verifies the behavior when adding more items than the maxCacheSize limit
-func TestMaxCacheSize(t *testing.T) {
-	// Create a cache with a small limit
-	smallLimit := int64(5)
-	cache := NewWithSize(5*time.Second, DefaultMaxMemorySize, smallLimit)
-
-	// Add entries with increasing size (to avoid memory-based eviction)
-	for i := 0; i < 20; i++ {
-		key := fmt.Sprintf("test-key-%d", i)
-		value := []byte(key)
-		cache.Set(key, value, 10*time.Second)
-	}
-
-	// Verify we can get a reasonable number of items
-	// (we don't test for exact count as implementation may vary)
-	foundCount := 0
-	for i := 0; i < 20; i++ {
-		key := fmt.Sprintf("test-key-%d", i)
-		_, found := cache.Get(key)
-		if found {
-			foundCount++
-		}
-	}
-
-	// We should find some items but not all 20
-	assert.Greater(t, foundCount, 0, "Some items should be in the cache")
-	assert.LessOrEqual(t, foundCount, 20, "Not all items should be in the cache with small limit")
-}
-
-// TestGetMemoryUsage verifies that memory usage tracking is accurate
-func TestGetMemoryUsage(t *testing.T) {
-	cache := New(5 * time.Second)
-
-	// Initially memory usage should be 0
-	assert.Equal(t, int64(0), cache.GetMemoryUsage(), "Initial memory usage should be 0")
-
-	// Add an entry with a known approximate size
-	valueSize := 1024
-	value := make([]byte, valueSize)
-	key := "test-key"
-
-	cache.Set(key, value, 5*time.Second)
-
-	// Check memory usage - should be approximately valueSize + key length + overhead
-	expectedMinUsage := int64(valueSize + len(key))
-	memUsage := cache.GetMemoryUsage()
-	assert.GreaterOrEqual(t, memUsage, expectedMinUsage,
-		"Memory usage (%d) should be at least the value size plus key length (%d)", memUsage, expectedMinUsage)
-
-	// Delete the entry and verify memory usage decreases
-	cache.Delete(key)
-	assert.Equal(t, int64(0), cache.GetMemoryUsage(), "Memory usage should be 0 after deletion")
-}
-
-// TestSetMaxMemorySize tests changing the memory limit and resulting eviction
-func TestSetMaxMemorySize(t *testing.T) {
-	// Start with a large limit
-	initialLimit := int64(100 * 1024)
-	cache := NewWithSize(5*time.Second, initialLimit, 1000)
-
-	// Fill the cache with ~50KB of data
-	valueSize := 1024
-	numEntries := 50
-
-	for i := 0; i < numEntries; i++ {
-		key := generateKey(i)
-		value := make([]byte, valueSize)
-		cache.Set(key, value, 5*time.Second)
-
-		// Small delay for timestamp differences
-		time.Sleep(time.Millisecond)
-	}
-
-	// Verify all entries exist
-	for i := 0; i < numEntries; i++ {
-		_, found := cache.Get(generateKey(i))
-		assert.True(t, found, "All entries should exist before limit change")
-	}
-
-	// Get current memory usage
-	originalUsage := cache.GetMemoryUsage()
-
-	// Now reduce the limit to 20KB - should trigger eviction
-	newLimit := int64(20 * 1024)
-	cache.SetMaxMemorySize(newLimit)
-
-	// Verify memory usage is now below the new limit
-	newUsage := cache.GetMemoryUsage()
-	assert.LessOrEqual(t, newUsage, newLimit,
-		"After SetMaxMemorySize, memory usage (%d) should be less than or equal to new limit (%d)",
-		newUsage, newLimit)
-	assert.Less(t, newUsage, originalUsage,
-		"Memory usage should have decreased after lowering the limit")
-
-	// Some older entries should be gone, newer ones should still exist
-	removedCount := 0
-	remainingCount := 0
-	for i := 0; i < numEntries; i++ {
-		_, found := cache.Get(generateKey(i))
-		if found {
-			remainingCount++
-		} else {
-			removedCount++
-		}
-	}
-
-	assert.Greater(t, removedCount, 0, "Some entries should have been removed")
-	assert.Greater(t, remainingCount, 0, "Some entries should still exist")
-}
-
-// Helper function to generate consistent keys
-func generateKey(index int) string {
-	return "test-key-" + fmt.Sprintf("%d", index)
-}

cache/memory/lru_memory_cache.go

@@ -1,286 +0,0 @@
-package libpack_cache_memory
-
-import (
-	"compress/gzip"
-	"container/list"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// LRUMemoryCache is an efficient LRU-based memory cache implementation
-type LRUMemoryCache struct {
-	entries        map[string]*lruEntry
-	evictList      *list.List
-	gzipWriterPool *sync.Pool
-	gzipReaderPool *sync.Pool
-	maxMemorySize  int64
-	maxEntries     int64
-	currentMemory  int64
-	currentCount   int64
-	mu             sync.RWMutex
-}
-
-type lruEntry struct {
-	expiresAt  time.Time
-	element    *list.Element
-	key        string
-	value      []byte
-	size       int64
-	compressed bool
-}
-
-// NewLRUMemoryCache creates a new LRU memory cache
-func NewLRUMemoryCache(maxMemorySize, maxEntries int64) *LRUMemoryCache {
-	return &LRUMemoryCache{
-		maxMemorySize: maxMemorySize,
-		maxEntries:    maxEntries,
-		entries:       make(map[string]*lruEntry),
-		evictList:     list.New(),
-		gzipWriterPool: &sync.Pool{
-			New: func() interface{} {
-				return gzip.NewWriter(nil)
-			},
-		},
-		gzipReaderPool: &sync.Pool{
-			New: func() interface{} {
-				return &gzip.Reader{}
-			},
-		},
-	}
-}
-
-// Set adds or updates an entry in the cache
-func (c *LRUMemoryCache) Set(key string, value []byte, ttl time.Duration) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Calculate expiry time
-	expiresAt := time.Now().Add(ttl)
-
-	// Check if we should compress
-	compressed := false
-	finalValue := value
-	if len(value) > 1024 { // Compress if larger than 1KB
-		if compressedData, err := c.compress(value); err == nil && len(compressedData) < len(value) {
-			compressed = true
-			finalValue = compressedData
-		}
-	}
-
-	entrySize := int64(len(key) + len(finalValue) + 64) // 64 bytes overhead estimate
-
-	// Check if key exists
-	if existing, exists := c.entries[key]; exists {
-		// Update existing entry
-		c.evictList.MoveToFront(existing.element)
-		atomic.AddInt64(&c.currentMemory, -existing.size)
-		atomic.AddInt64(&c.currentMemory, entrySize)
-
-		existing.value = finalValue
-		existing.compressed = compressed
-		existing.size = entrySize
-		existing.expiresAt = expiresAt
-
-		c.evictIfNeeded()
-		return
-	}
-
-	// Create new entry
-	entry := &lruEntry{
-		key:        key,
-		value:      finalValue,
-		compressed: compressed,
-		size:       entrySize,
-		expiresAt:  expiresAt,
-	}
-
-	element := c.evictList.PushFront(entry)
-	entry.element = element
-	c.entries[key] = entry
-
-	atomic.AddInt64(&c.currentMemory, entrySize)
-	atomic.AddInt64(&c.currentCount, 1)
-
-	c.evictIfNeeded()
-}
-
-// Get retrieves a value from the cache
-func (c *LRUMemoryCache) Get(key string) ([]byte, bool) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	entry, exists := c.entries[key]
-	if !exists {
-		return nil, false
-	}
-
-	// Check if expired
-	if time.Now().After(entry.expiresAt) {
-		c.removeEntry(entry)
-		return nil, false
-	}
-
-	// Move to front (most recently used)
-	c.evictList.MoveToFront(entry.element)
-
-	// Decompress if needed
-	if entry.compressed {
-		if decompressed, err := c.decompress(entry.value); err == nil {
-			return decompressed, true
-		}
-		// If decompression fails, remove the entry
-		c.removeEntry(entry)
-		return nil, false
-	}
-
-	return entry.value, true
-}
-
-// Delete removes an entry from the cache
-func (c *LRUMemoryCache) Delete(key string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	if entry, exists := c.entries[key]; exists {
-		c.removeEntry(entry)
-	}
-}
-
-// Clear removes all entries
-func (c *LRUMemoryCache) Clear() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	c.entries = make(map[string]*lruEntry)
-	c.evictList = list.New()
-	atomic.StoreInt64(&c.currentMemory, 0)
-	atomic.StoreInt64(&c.currentCount, 0)
-}
-
-// evictIfNeeded removes entries when limits are exceeded
-func (c *LRUMemoryCache) evictIfNeeded() {
-	// Evict based on entry count
-	for atomic.LoadInt64(&c.currentCount) > c.maxEntries && c.evictList.Len() > 0 {
-		c.evictOldest()
-	}
-
-	// Evict based on memory
-	for atomic.LoadInt64(&c.currentMemory) > c.maxMemorySize && c.evictList.Len() > 0 {
-		c.evictOldest()
-	}
-}
-
-// evictOldest removes the least recently used entry
-func (c *LRUMemoryCache) evictOldest() {
-	element := c.evictList.Back()
-	if element == nil {
-		return
-	}
-
-	entry := element.Value.(*lruEntry)
-	c.removeEntry(entry)
-}
-
-// removeEntry removes an entry from all data structures
-func (c *LRUMemoryCache) removeEntry(entry *lruEntry) {
-	c.evictList.Remove(entry.element)
-	delete(c.entries, entry.key)
-	atomic.AddInt64(&c.currentMemory, -entry.size)
-	atomic.AddInt64(&c.currentCount, -1)
-}
-
-// CleanExpiredEntries removes all expired entries
-func (c *LRUMemoryCache) CleanExpiredEntries() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	now := time.Now()
-	for element := c.evictList.Back(); element != nil; {
-		entry := element.Value.(*lruEntry)
-
-		if now.After(entry.expiresAt) {
-			next := element.Prev()
-			c.removeEntry(entry)
-			element = next
-		} else {
-			element = element.Prev()
-		}
-	}
-}
-
-// compress compresses data using gzip
-func (c *LRUMemoryCache) compress(data []byte) ([]byte, error) {
-	buf := GetBuffer()
-	defer PutBuffer(buf)
-
-	gz := c.gzipWriterPool.Get().(*gzip.Writer)
-	gz.Reset(buf)
-	defer c.gzipWriterPool.Put(gz)
-
-	if _, err := gz.Write(data); err != nil {
-		return nil, err
-	}
-	if err := gz.Close(); err != nil {
-		return nil, err
-	}
-
-	compressed := make([]byte, buf.Len())
-	copy(compressed, buf.Bytes())
-	return compressed, nil
-}
-
-// decompress decompresses gzip data
-func (c *LRUMemoryCache) decompress(data []byte) ([]byte, error) {
-	buf := GetBuffer()
-	defer PutBuffer(buf)
-
-	buf.Write(data)
-
-	gr := c.gzipReaderPool.Get().(*gzip.Reader)
-	defer c.gzipReaderPool.Put(gr)
-
-	if err := gr.Reset(buf); err != nil {
-		return nil, err
-	}
-
-	result := GetBuffer()
-	defer PutBuffer(result)
-
-	if _, err := result.ReadFrom(gr); err != nil {
-		return nil, err
-	}
-
-	decompressed := make([]byte, result.Len())
-	copy(decompressed, result.Bytes())
-	return decompressed, nil
-}
-
-// GetStats returns cache statistics
-func (c *LRUMemoryCache) GetStats() map[string]interface{} {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return map[string]interface{}{
-		"entries":      atomic.LoadInt64(&c.currentCount),
-		"memory_bytes": atomic.LoadInt64(&c.currentMemory),
-		"max_entries":  c.maxEntries,
-		"max_memory":   c.maxMemorySize,
-		"fill_percent": float64(atomic.LoadInt64(&c.currentMemory)) / float64(c.maxMemorySize) * 100,
-	}
-}
-
-// GetMemoryUsage returns current memory usage in bytes
-func (c *LRUMemoryCache) GetMemoryUsage() int64 {
-	return atomic.LoadInt64(&c.currentMemory)
-}
-
-// GetMaxMemorySize returns the maximum memory size
-func (c *LRUMemoryCache) GetMaxMemorySize() int64 {
-	return c.maxMemorySize
-}
-
-// CountQueries returns the number of entries in the cache
-func (c *LRUMemoryCache) CountQueries() int64 {
-	return atomic.LoadInt64(&c.currentCount)
-}

cache/memory/lru_memory_cache_test.go

@@ -1,343 +0,0 @@
-package libpack_cache_memory
-
-import (
-	"fmt"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/suite"
-)
-
-type LRUMemoryCacheTestSuite struct {
-	suite.Suite
-}
-
-func TestLRUMemoryCacheTestSuite(t *testing.T) {
-	suite.Run(t, new(LRUMemoryCacheTestSuite))
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestNewLRUMemoryCache() {
-	cache := NewLRUMemoryCache(1024*1024, 100) // 1MB, 100 entries
-	suite.NotNil(cache)
-	suite.Equal(int64(0), cache.CountQueries())
-	suite.Equal(int64(0), cache.GetMemoryUsage())
-	suite.Equal(int64(1024*1024), cache.GetMaxMemorySize())
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestSetAndGet() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	// Set a value
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-
-	// Get the value
-	val, found := cache.Get("key1")
-	suite.True(found)
-	suite.Equal([]byte("value1"), val)
-
-	// Get non-existent key
-	val, found = cache.Get("nonexistent")
-	suite.False(found)
-	suite.Nil(val)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestUpdateExisting() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	cache.Set("key1", []byte("value2"), 5*time.Second)
-
-	val, found := cache.Get("key1")
-	suite.True(found)
-	suite.Equal([]byte("value2"), val)
-	suite.Equal(int64(1), cache.CountQueries())
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestDelete() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	suite.Equal(int64(1), cache.CountQueries())
-
-	cache.Delete("key1")
-	suite.Equal(int64(0), cache.CountQueries())
-
-	val, found := cache.Get("key1")
-	suite.False(found)
-	suite.Nil(val)
-
-	// Delete non-existent key should not panic
-	cache.Delete("nonexistent")
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestClear() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	cache.Set("key2", []byte("value2"), 5*time.Second)
-	cache.Set("key3", []byte("value3"), 5*time.Second)
-	suite.Equal(int64(3), cache.CountQueries())
-
-	cache.Clear()
-	suite.Equal(int64(0), cache.CountQueries())
-	suite.Equal(int64(0), cache.GetMemoryUsage())
-
-	_, found := cache.Get("key1")
-	suite.False(found)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestExpiration() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	cache.Set("key1", []byte("value1"), 100*time.Millisecond)
-
-	// Should exist immediately
-	val, found := cache.Get("key1")
-	suite.True(found)
-	suite.Equal([]byte("value1"), val)
-
-	// Wait for expiration
-	time.Sleep(150 * time.Millisecond)
-
-	// Should be expired
-	val, found = cache.Get("key1")
-	suite.False(found)
-	suite.Nil(val)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestEvictionByCount() {
-	cache := NewLRUMemoryCache(1024*1024, 3) // Max 3 entries
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	cache.Set("key2", []byte("value2"), 5*time.Second)
-	cache.Set("key3", []byte("value3"), 5*time.Second)
-
-	// All 3 should exist
-	_, found := cache.Get("key1")
-	suite.True(found)
-	_, found = cache.Get("key2")
-	suite.True(found)
-	_, found = cache.Get("key3")
-	suite.True(found)
-
-	// Add 4th entry - should evict oldest (key1)
-	cache.Set("key4", []byte("value4"), 5*time.Second)
-
-	suite.Equal(int64(3), cache.CountQueries())
-
-	// key1 should be evicted (it was least recently used)
-	_, found = cache.Get("key1")
-	suite.False(found)
-
-	// Others should still exist
-	_, found = cache.Get("key2")
-	suite.True(found)
-	_, found = cache.Get("key3")
-	suite.True(found)
-	_, found = cache.Get("key4")
-	suite.True(found)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestLRUOrder() {
-	cache := NewLRUMemoryCache(1024*1024, 3) // Max 3 entries
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	cache.Set("key2", []byte("value2"), 5*time.Second)
-	cache.Set("key3", []byte("value3"), 5*time.Second)
-
-	// Access key1 to make it recently used
-	cache.Get("key1")
-
-	// Add key4 - should evict key2 (now least recently used)
-	cache.Set("key4", []byte("value4"), 5*time.Second)
-
-	// key2 should be evicted
-	_, found := cache.Get("key2")
-	suite.False(found)
-
-	// key1 should still exist (was accessed recently)
-	_, found = cache.Get("key1")
-	suite.True(found)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestEvictionByMemory() {
-	// Small memory limit - 500 bytes
-	cache := NewLRUMemoryCache(500, 100)
-
-	// Each entry has ~64 bytes overhead + key + value
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	cache.Set("key2", []byte("value2"), 5*time.Second)
-	cache.Set("key3", []byte("value3"), 5*time.Second)
-
-	// Add large entry that should trigger eviction
-	largeValue := make([]byte, 200)
-	cache.Set("large", largeValue, 5*time.Second)
-
-	// Memory should be under limit
-	suite.LessOrEqual(cache.GetMemoryUsage(), int64(500))
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestCompression() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	// Create a compressible value (> 1KB to trigger compression)
-	largeValue := make([]byte, 2048)
-	for i := range largeValue {
-		largeValue[i] = 'A' // Highly compressible
-	}
-
-	cache.Set("compressed", largeValue, 5*time.Second)
-
-	// Should be able to retrieve it correctly
-	val, found := cache.Get("compressed")
-	suite.True(found)
-	suite.Equal(largeValue, val)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestGetStats() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	cache.Set("key2", []byte("value2"), 5*time.Second)
-
-	stats := cache.GetStats()
-	suite.Equal(int64(2), stats["entries"])
-	suite.Equal(int64(1024*1024), stats["max_memory"])
-	suite.Equal(int64(100), stats["max_entries"])
-	suite.NotNil(stats["memory_bytes"])
-	suite.NotNil(stats["fill_percent"])
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestConcurrentAccess() {
-	cache := NewLRUMemoryCache(10*1024*1024, 1000)
-	const numGoroutines = 50
-	const numOperations = 500
-
-	var wg sync.WaitGroup
-	wg.Add(numGoroutines * 3) // readers, writers, deleters
-
-	// Writers
-	for i := 0; i < numGoroutines; i++ {
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < numOperations; j++ {
-				key := fmt.Sprintf("key-%d-%d", id, j)
-				value := []byte(fmt.Sprintf("value-%d-%d", id, j))
-				cache.Set(key, value, 5*time.Second)
-			}
-		}(i)
-	}
-
-	// Readers
-	for i := 0; i < numGoroutines; i++ {
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < numOperations; j++ {
-				key := fmt.Sprintf("key-%d-%d", id, j)
-				cache.Get(key)
-			}
-		}(i)
-	}
-
-	// Deleters
-	for i := 0; i < numGoroutines; i++ {
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < numOperations; j++ {
-				key := fmt.Sprintf("key-%d-%d", id, j%100)
-				cache.Delete(key)
-			}
-		}(i)
-	}
-
-	wg.Wait()
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestCleanExpiredEntries() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	cache.Set("expire1", []byte("value1"), 50*time.Millisecond)
-	cache.Set("expire2", []byte("value2"), 50*time.Millisecond)
-	cache.Set("keep", []byte("value3"), 5*time.Second)
-
-	suite.Equal(int64(3), cache.CountQueries())
-
-	// Wait for some to expire
-	time.Sleep(100 * time.Millisecond)
-
-	// Clean expired entries
-	cache.CleanExpiredEntries()
-
-	// Only "keep" should remain
-	suite.Equal(int64(1), cache.CountQueries())
-
-	_, found := cache.Get("keep")
-	suite.True(found)
-}
-
-func (suite *LRUMemoryCacheTestSuite) TestCountQueries() {
-	cache := NewLRUMemoryCache(1024*1024, 100)
-
-	suite.Equal(int64(0), cache.CountQueries())
-
-	cache.Set("key1", []byte("value1"), 5*time.Second)
-	suite.Equal(int64(1), cache.CountQueries())
-
-	cache.Set("key2", []byte("value2"), 5*time.Second)
-	suite.Equal(int64(2), cache.CountQueries())
-
-	cache.Delete("key1")
-	suite.Equal(int64(1), cache.CountQueries())
-
-	cache.Clear()
-	suite.Equal(int64(0), cache.CountQueries())
-}
-
-// Benchmarks
-
-func BenchmarkLRUMemoryCacheSet(b *testing.B) {
-	cache := NewLRUMemoryCache(100*1024*1024, 100000)
-	value := []byte("benchmark-value")
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		key := fmt.Sprintf("key-%d", i)
-		cache.Set(key, value, 5*time.Second)
-	}
-}
-
-func BenchmarkLRUMemoryCacheGet(b *testing.B) {
-	cache := NewLRUMemoryCache(100*1024*1024, 100000)
-	value := []byte("benchmark-value")
-
-	// Pre-populate
-	for i := 0; i < 10000; i++ {
-		key := fmt.Sprintf("key-%d", i)
-		cache.Set(key, value, 5*time.Minute)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		key := fmt.Sprintf("key-%d", i%10000)
-		cache.Get(key)
-	}
-}
-
-func BenchmarkLRUMemoryCacheConcurrent(b *testing.B) {
-	cache := NewLRUMemoryCache(100*1024*1024, 100000)
-	value := []byte("benchmark-value")
-
-	b.RunParallel(func(pb *testing.PB) {
-		i := 0
-		for pb.Next() {
-			key := fmt.Sprintf("key-%d", i)
-			if i%2 == 0 {
-				cache.Set(key, value, 5*time.Second)
-			} else {
-				cache.Get(key)
-			}
-			i++
-		}
-	})
-}

cache/memory/memory.go

@@ -3,63 +3,28 @@ package libpack_cache_memory
 import (
 	"bytes"
 	"compress/gzip"
-	"context"
 	"io"
+	"log"
 	"sync"
-	"sync/atomic"
 	"time"
 )
 
-// CompressionThreshold is the minimum size in bytes before a value is compressed
-const CompressionThreshold = 1024 // 1KB
-
-// DefaultMaxMemorySize is the default maximum memory size in bytes (100MB)
-const DefaultMaxMemorySize = 100 * 1024 * 1024
-
-// DefaultMaxCacheSize is the default maximum number of entries in the cache
-// This is used for backward compatibility
-const DefaultMaxCacheSize = 10000
-
-// approxEntryOverhead is the estimated overhead per cache entry in bytes
-// This accounts for the CacheEntry struct overhead, map entry, and synchronization
-const approxEntryOverhead = 64
-
 type CacheEntry struct {
-	ExpiresAt  time.Time
-	Value      []byte
-	Compressed bool
-	MemorySize int64 // Estimated memory usage of this entry in bytes
+	ExpiresAt time.Time
+	Value     []byte
 }
 
 type Cache struct {
 	compressPool   sync.Pool
 	decompressPool sync.Pool
-	ctx            context.Context
-	cancel         context.CancelFunc
 	entries        sync.Map
 	globalTTL      time.Duration
-	entryCount     int64
-	memoryUsage    int64
-	maxMemorySize  int64
-	maxCacheSize   int64
 	sync.RWMutex
 }
 
 func New(globalTTL time.Duration) *Cache {
-	return NewWithSize(globalTTL, DefaultMaxMemorySize, DefaultMaxCacheSize)
-}
-
-// NewWithSize creates a new cache with the specified memory size limit and entry count limit
-func NewWithSize(globalTTL time.Duration, maxMemorySize int64, maxCacheSize int64) *Cache {
-	// Create context for graceful shutdown
-	ctx, cancel := context.WithCancel(context.Background())
-
 	cache := &Cache{
-		globalTTL:     globalTTL,
-		maxMemorySize: maxMemorySize,
-		maxCacheSize:  maxCacheSize,
-		ctx:           ctx,
-		cancel:        cancel,
+		globalTTL: globalTTL,
 		compressPool: sync.Pool{
 			New: func() interface{} {
 				return gzip.NewWriter(nil)
@@ -73,100 +38,32 @@ func NewWithSize(globalTTL time.Duration, maxMemorySize int64, maxCacheSize int6
 		},
 	}
 
-	// Start cleanup routine with context cancellation
 	go cache.cleanupRoutine(globalTTL)
 	return cache
 }
 
 func (c *Cache) cleanupRoutine(globalTTL time.Duration) {
-	// Clean up more frequently when the cache is large
-	ticker := time.NewTicker(globalTTL / 4)
+	ticker := time.NewTicker(globalTTL / 2)
 	defer ticker.Stop()
 
-	for {
-		select {
-		case <-c.ctx.Done():
-			// Context cancelled, exit gracefully
-			return
-		case <-ticker.C:
-			c.CleanExpiredEntries()
-
-			// Note: Removed aggressive GC trigger that was causing performance issues
-			// The Go runtime GC is already optimized and will run when needed
-		}
-	}
-}
-
-// Shutdown gracefully stops the cache cleanup routine
-func (c *Cache) Shutdown() {
-	if c.cancel != nil {
-		c.cancel()
+	for range ticker.C {
+		c.CleanExpiredEntries()
 	}
 }
 
 func (c *Cache) Set(key string, value []byte, ttl time.Duration) {
-	// Calculate the memory size of this entry
-	entrySize := int64(len(key) + len(value) + approxEntryOverhead)
-
-	// Check if we need to evict entries based on memory or count limits
-	currentMemory := atomic.LoadInt64(&c.memoryUsage)
-	if currentMemory+entrySize > c.maxMemorySize {
-		// Need to evict based on memory
-		memoryToFree := (currentMemory + entrySize) - c.maxMemorySize + (c.maxMemorySize / 10)
-		c.evictToFreeMemory(memoryToFree)
-	} else if atomic.LoadInt64(&c.entryCount) >= c.maxCacheSize {
-		// Fall back to count-based eviction for backward compatibility
-		c.evictOldest(int(c.maxCacheSize / 10)) // Evict 10% of entries
-	}
-
 	expiresAt := time.Now().Add(ttl)
 
-	// Only compress if the value is larger than the threshold
-	var entry CacheEntry
-	if len(value) > CompressionThreshold {
-		compressedValue, err := c.compress(value)
-		if err == nil && len(compressedValue) < len(value) {
-			entry = CacheEntry{
-				Value:      compressedValue,
-				ExpiresAt:  expiresAt,
-				Compressed: true,
-			}
-		} else {
-			// If compression failed or didn't reduce size, store uncompressed
-			entry = CacheEntry{
-				Value:      value,
-				ExpiresAt:  expiresAt,
-				Compressed: false,
-			}
-		}
-	} else {
-		entry = CacheEntry{
-			Value:      value,
-			ExpiresAt:  expiresAt,
-			Compressed: false,
-		}
+	compressedValue, err := c.compress(value)
+	if err != nil {
+		log.Printf("Error compressing value for key %s: %v", key, err)
+		return
 	}
 
-	// Update the entry memory size based on compression status
-	if entry.Compressed {
-		entry.MemorySize = int64(len(key) + len(entry.Value) + approxEntryOverhead)
-	} else {
-		entry.MemorySize = int64(len(key) + len(entry.Value) + approxEntryOverhead)
+	entry := CacheEntry{
+		Value:     compressedValue,
+		ExpiresAt: expiresAt,
 	}
-
-	// Check if this is a new entry or an update
-	oldEntry, exists := c.entries.Load(key)
-	if exists {
-		// Update memory usage: subtract old entry size, add new entry size
-		oldCacheEntry := oldEntry.(CacheEntry)
-		atomic.AddInt64(&c.memoryUsage, -oldCacheEntry.MemorySize)
-	} else {
-		// New entry
-		atomic.AddInt64(&c.entryCount, 1)
-	}
-
-	// Add new entry's memory size to total
-	atomic.AddInt64(&c.memoryUsage, entry.MemorySize)
 	c.entries.Store(key, entry)
 }
 
@@ -179,28 +76,19 @@ func (c *Cache) Get(key string) ([]byte, bool) {
 	cacheEntry := entry.(CacheEntry)
 	if cacheEntry.ExpiresAt.Before(time.Now()) {
 		c.entries.Delete(key)
-		atomic.AddInt64(&c.entryCount, -1)
-		atomic.AddInt64(&c.memoryUsage, -cacheEntry.MemorySize)
 		return nil, false
 	}
 
-	if cacheEntry.Compressed {
-		value, err := c.decompress(cacheEntry.Value)
-		if err != nil {
-			return nil, false
-		}
-		return value, true
+	value, err := c.decompress(cacheEntry.Value)
+	if err != nil {
+		log.Printf("Error decompressing value for key %s: %v", key, err)
+		return nil, false
 	}
-
-	return cacheEntry.Value, true
+	return value, true
 }
 
 func (c *Cache) Delete(key string) {
-	if entry, exists := c.entries.LoadAndDelete(key); exists {
-		cacheEntry := entry.(CacheEntry)
-		atomic.AddInt64(&c.entryCount, -1)
-		atomic.AddInt64(&c.memoryUsage, -cacheEntry.MemorySize)
-	}
+	c.entries.Delete(key)
 }
 
 func (c *Cache) Clear() {
@@ -208,19 +96,24 @@ func (c *Cache) Clear() {
 		c.entries.Delete(key)
 		return true
 	})
-	atomic.StoreInt64(&c.entryCount, 0)
-	atomic.StoreInt64(&c.memoryUsage, 0)
 }
 
 func (c *Cache) CountQueries() int64 {
-	return atomic.LoadInt64(&c.entryCount)
+	var count int
+	c.entries.Range(func(_, _ interface{}) bool {
+		count++
+		return true
+	})
+	return int64(count)
 }
 
 func (c *Cache) compress(data []byte) ([]byte, error) {
 	var buf bytes.Buffer
 	w := c.compressPool.Get().(*gzip.Writer)
-	defer c.compressPool.Put(w)
-
+	defer func() {
+		w.Close()
+		c.compressPool.Put(w)
+	}()
 	w.Reset(&buf)
 	if _, err := w.Write(data); err != nil {
 		return nil, err
@@ -233,8 +126,6 @@ func (c *Cache) compress(data []byte) ([]byte, error) {
 
 func (c *Cache) decompress(data []byte) ([]byte, error) {
 	r, ok := c.decompressPool.Get().(*gzip.Reader)
-	defer c.decompressPool.Put(r)
-
 	if !ok || r == nil {
 		var err error
 		r, err = gzip.NewReader(bytes.NewReader(data))
@@ -246,10 +137,11 @@ func (c *Cache) decompress(data []byte) ([]byte, error) {
 			return nil, err
 		}
 	}
-
 	defer func() {
-		_ = r.Close() // Ignore error in defer cleanup
+		r.Close()
+		c.decompressPool.Put(r)
 	}()
+
 	return io.ReadAll(r)
 }
 
@@ -258,114 +150,8 @@ func (c *Cache) CleanExpiredEntries() {
 	c.entries.Range(func(key, value interface{}) bool {
 		entry := value.(CacheEntry)
 		if entry.ExpiresAt.Before(now) {
-			if _, exists := c.entries.LoadAndDelete(key); exists {
-				atomic.AddInt64(&c.entryCount, -1)
-				atomic.AddInt64(&c.memoryUsage, -entry.MemorySize)
-			}
+			c.entries.Delete(key)
 		}
 		return true
 	})
 }
-
-// evictOldest removes the oldest n entries from the cache
-func (c *Cache) evictOldest(n int) {
-	type keyExpiry struct {
-		expiresAt time.Time
-		key       string
-	}
-
-	// Collect all entries with their expiry times
-	entries := make([]keyExpiry, 0, n*2)
-	c.entries.Range(func(k, v interface{}) bool {
-		key := k.(string)
-		entry := v.(CacheEntry)
-		entries = append(entries, keyExpiry{entry.ExpiresAt, key})
-		return len(entries) < cap(entries)
-	})
-
-	// Sort by expiry time (oldest first)
-	// Using a simple selection sort since we only need to find the n oldest
-	for i := 0; i < n && i < len(entries); i++ {
-		oldest := i
-		for j := i + 1; j < len(entries); j++ {
-			if entries[j].expiresAt.Before(entries[oldest].expiresAt) {
-				oldest = j
-			}
-		}
-		// Swap
-		if oldest != i {
-			entries[i], entries[oldest] = entries[oldest], entries[i]
-		}
-
-		// Delete this entry
-		if entry, exists := c.entries.LoadAndDelete(entries[i].key); exists {
-			cacheEntry := entry.(CacheEntry)
-			atomic.AddInt64(&c.entryCount, -1)
-			atomic.AddInt64(&c.memoryUsage, -cacheEntry.MemorySize)
-		}
-	}
-}
-
-// evictToFreeMemory removes entries until the specified amount of memory is freed
-func (c *Cache) evictToFreeMemory(bytesToFree int64) {
-	type keyMemorySize struct {
-		expiresAt  time.Time
-		key        string
-		memorySize int64
-	}
-
-	// Collect entries to consider for eviction
-	entries := make([]keyMemorySize, 0, int(c.maxCacheSize/5))
-	c.entries.Range(func(k, v interface{}) bool {
-		key := k.(string)
-		entry := v.(CacheEntry)
-		entries = append(entries, keyMemorySize{entry.ExpiresAt, key, entry.MemorySize})
-		return len(entries) < cap(entries)
-	})
-
-	// Sort entries by expiry time (oldest first)
-	// Simple selection sort since we only need to find the oldest entries
-	var freedBytes int64
-	for i := 0; i < len(entries) && freedBytes < bytesToFree; i++ {
-		oldest := i
-		for j := i + 1; j < len(entries); j++ {
-			if entries[j].expiresAt.Before(entries[oldest].expiresAt) {
-				oldest = j
-			}
-		}
-		// Swap
-		if oldest != i {
-			entries[i], entries[oldest] = entries[oldest], entries[i]
-		}
-
-		// Delete this entry
-		if entry, exists := c.entries.LoadAndDelete(entries[i].key); exists {
-			cacheEntry := entry.(CacheEntry)
-			atomic.AddInt64(&c.entryCount, -1)
-			atomic.AddInt64(&c.memoryUsage, -cacheEntry.MemorySize)
-			freedBytes += cacheEntry.MemorySize
-		}
-	}
-}
-
-// GetMemoryUsage returns the current memory usage of the cache in bytes
-func (c *Cache) GetMemoryUsage() int64 {
-	return atomic.LoadInt64(&c.memoryUsage)
-}
-
-// GetMaxMemorySize returns the maximum memory size allowed for the cache in bytes
-func (c *Cache) GetMaxMemorySize() int64 {
-	return c.maxMemorySize
-}
-
-// SetMaxMemorySize updates the maximum memory size allowed for the cache
-func (c *Cache) SetMaxMemorySize(maxBytes int64) {
-	c.maxMemorySize = maxBytes
-
-	// Check if we need to evict entries due to the new limit
-	currentMemory := atomic.LoadInt64(&c.memoryUsage)
-	if currentMemory > maxBytes {
-		memoryToFree := currentMemory - maxBytes + (maxBytes / 10)
-		c.evictToFreeMemory(memoryToFree)
-	}
-}

cache/memory/memory_additional_test.go

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

cache/redis/redis.go

@@ -3,9 +3,10 @@ package libpack_cache_redis
 import (
 	"context"
 	"strings"
-	"sync"
 	"time"
 
+	"sync"
+
 	redis "github.com/redis/go-redis/v9"
 )
 
@@ -32,7 +33,7 @@ type RedisClientConfig struct {
 	RedisDB       int
 }
 
-func New(redisClientConfig *RedisClientConfig) (*RedisConfig, error) {
+func New(redisClientConfig *RedisClientConfig) *RedisConfig {
 	c := &RedisConfig{
 		client: redis.NewClient(&redis.Options{
 			Addr:     redisClientConfig.RedisServer,
@@ -50,72 +51,46 @@ func New(redisClientConfig *RedisClientConfig) (*RedisConfig, error) {
 
 	_, err := c.client.Ping(c.ctx).Result()
 	if err != nil {
-		return nil, err
+		panic(err)
 	}
-	return c, nil
+	return c
 }
 
-func (c *RedisConfig) Set(key string, value []byte, ttl time.Duration) error {
-	return c.client.Set(c.ctx, c.prependKeyName(key), value, ttl).Err()
+func (c *RedisConfig) Set(key string, value []byte, ttl time.Duration) {
+	c.client.Set(c.ctx, c.prependKeyName(key), value, ttl)
 }
 
-func (c *RedisConfig) Get(key string) ([]byte, bool, error) {
+func (c *RedisConfig) Get(key string) ([]byte, bool) {
 	val, err := c.client.Get(c.ctx, c.prependKeyName(key)).Result()
 	if err == redis.Nil {
-		return nil, false, nil
+		return nil, false
 	}
 	if err != nil {
-		return nil, false, err
+		return nil, false
 	}
-	return []byte(val), true, nil
+	return []byte(val), true
 }
 
-func (c *RedisConfig) Delete(key string) error {
-	return c.client.Del(c.ctx, c.prependKeyName(key)).Err()
+func (c *RedisConfig) Delete(key string) {
+	c.client.Del(c.ctx, c.prependKeyName(key))
 }
 
-func (c *RedisConfig) Clear() error {
-	return c.client.FlushDB(c.ctx).Err()
+func (c *RedisConfig) Clear() {
+	c.client.FlushDB(c.ctx)
 }
 
-func (c *RedisConfig) CountQueries() (int64, error) {
+func (c *RedisConfig) CountQueries() int64 {
 	keys, err := c.client.Keys(c.ctx, c.prependKeyName("*")).Result()
-	if err != nil {
-		return 0, err
-	}
-	return int64(len(keys)), nil
-}
-
-func (c *RedisConfig) CountQueriesWithPattern(pattern string) (int, error) {
-	keys, err := c.client.Keys(c.ctx, c.prependKeyName(pattern)).Result()
-	if err != nil {
-		return 0, err
-	}
-	return len(keys), nil
-}
-
-// GetMemoryUsage returns an approximation of memory usage for Redis
-// For Redis, this is not as accurate as the memory cache implementation
-// as actual memory is managed by Redis server
-func (c *RedisConfig) GetMemoryUsage() int64 {
-	// We could attempt to get memory usage from Redis info
-	// but for now, we'll just return 0 since Redis manages its own memory
-	// and this information would require parsing the INFO command output
-	_, err := c.client.Info(c.ctx, "memory").Result()
 	if err != nil {
 		return 0
 	}
-
-	// Just return 0 as a placeholder since Redis manages its own memory
-	// In a production environment, you could parse the Redis INFO command result
-	// to extract actual "used_memory" value
-	return 0
+	return int64(len(keys))
 }
 
-// GetMaxMemorySize returns the configured max memory for Redis
-// In Redis, this would be the 'maxmemory' configuration value
-func (c *RedisConfig) GetMaxMemorySize() int64 {
-	// Return a default value as Redis manages its own memory limits
-	// In a production environment, you could get this from Redis config
-	return 0
+func (c *RedisConfig) CountQueriesWithPattern(pattern string) int {
+	keys, err := c.client.Keys(c.ctx, c.prependKeyName(pattern)).Result()
+	if err != nil {
+		return 0
+	}
+	return len(keys)
 }

cache/redis/redis_additional_test.go

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

cache/redis/redis_test.go

@@ -17,13 +17,11 @@ type RedisConfigSuite struct {
 
 func (suite *RedisConfigSuite) SetupTest() {
 	suite.redis_server, _ = miniredis.Run()
-	var err error
-	suite.redisConfig, err = New(&RedisClientConfig{
+	suite.redisConfig = New(&RedisClientConfig{
 		RedisServer:   suite.redis_server.Addr(),
 		RedisPassword: "",
 		RedisDB:       0,
 	})
-	assert.NoError(suite.T(), err)
 	suite.redisConfig.Delete("testkey")
 }
 
@@ -37,19 +35,15 @@ func (suite *RedisConfigSuite) TestSet() {
 	suite.redisConfig.Delete(key) // Ensure the key is deleted before the test
 
 	// Test writing a new key-value pair
-	err := suite.redisConfig.Set(key, value, 0)
-	assert.NoError(suite.T(), err)
-	storedValue, found, err := suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set(key, value, 0)
+	storedValue, found := suite.redisConfig.Get(key)
 	assert.True(suite.T(), found)
 	assert.Equal(suite.T(), value, storedValue)
 
 	// Test overwriting an existing key-value pair
 	newValue := []byte("newvalue")
-	err = suite.redisConfig.Set(key, newValue, 0)
-	assert.NoError(suite.T(), err)
-	storedValue, found, err = suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set(key, newValue, 0)
+	storedValue, found = suite.redisConfig.Get(key)
 	assert.True(suite.T(), found)
 	assert.Equal(suite.T(), newValue, storedValue)
 
@@ -63,20 +57,16 @@ func (suite *RedisConfigSuite) TestSetWithExpiry() {
 	suite.redisConfig.Delete(key) // Ensure the key is deleted before the test
 
 	// Test writing a new key-value pair
-	err := suite.redisConfig.Set(key, value, expiry)
-	assert.NoError(suite.T(), err)
-	storedValue, found, err := suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set(key, value, expiry)
+	storedValue, found := suite.redisConfig.Get(key)
 	assert.True(suite.T(), found)
 	assert.Equal(suite.T(), value, storedValue)
-	_, found, err = suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	_, found = suite.redisConfig.Get(key)
 	assert.True(suite.T(), found, "Key should exist")
 
 	// Test that key expires after the specified time
 	suite.redis_server.FastForward(3 * time.Second)
-	_, found, err = suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	_, found = suite.redisConfig.Get(key)
 	assert.False(suite.T(), found, "Key should have expired after 2 seconds")
 
 	suite.redisConfig.Delete(key) // Clean up after the test
@@ -85,10 +75,8 @@ func (suite *RedisConfigSuite) TestSetWithExpiry() {
 func (suite *RedisConfigSuite) TestGet() {
 	key := "testkeyget"
 	value := []byte("testvalue")
-	err := suite.redisConfig.Set(key, value, 0) // Set the key-value pair
-	assert.NoError(suite.T(), err)
-	storedValue, found, err := suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set(key, value, 0) // Set the key-value pair
+	storedValue, found := suite.redisConfig.Get(key)
 	assert.True(suite.T(), found)
 	assert.Equal(suite.T(), value, storedValue)
 }
@@ -96,12 +84,9 @@ func (suite *RedisConfigSuite) TestGet() {
 func (suite *RedisConfigSuite) TestDeleteKey() {
 	key := "testkeydelete"
 	value := []byte("testvalue")
-	err := suite.redisConfig.Set(key, value, 0) // Set the key-value pair
-	assert.NoError(suite.T(), err)
-	err = suite.redisConfig.Delete(key)
-	assert.NoError(suite.T(), err)
-	_, found, err := suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set(key, value, 0) // Set the key-value pair
+	suite.redisConfig.Delete(key)
+	_, found := suite.redisConfig.Get(key)
 	assert.False(suite.T(), found)
 }
 
@@ -109,27 +94,20 @@ func (suite *RedisConfigSuite) TestCheckIfKeyExists() {
 	ttl := time.Duration(10) * time.Second
 	key := "testkeyifexists"
 	value := []byte("testvalue")
-	err := suite.redisConfig.Set(key, value, ttl) // Set the key-value pair
-	assert.NoError(suite.T(), err)
-	_, found, err := suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set(key, value, ttl) // Set the key-value pair
+	_, found := suite.redisConfig.Get(key)
 	assert.True(suite.T(), found)
 
-	err = suite.redisConfig.Delete(key)
-	assert.NoError(suite.T(), err)
-	_, found, err = suite.redisConfig.Get(key)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Delete(key)
+	_, found = suite.redisConfig.Get(key)
 	assert.False(suite.T(), found)
 }
 
 func (suite *RedisConfigSuite) TestGetKeys() {
 	ttl := time.Duration(10) * time.Second
-	err := suite.redisConfig.Set("testkey1", []byte("testvalue1"), ttl)
-	assert.NoError(suite.T(), err)
-	err = suite.redisConfig.Set("testkey2", []byte("testvalue2"), ttl)
-	assert.NoError(suite.T(), err)
-	err = suite.redisConfig.Set("otherkey", []byte("othervalue"), ttl)
-	assert.NoError(suite.T(), err)
+	suite.redisConfig.Set("testkey1", []byte("testvalue1"), ttl)
+	suite.redisConfig.Set("testkey2", []byte("testvalue2"), ttl)
+	suite.redisConfig.Set("otherkey", []byte("othervalue"), ttl)
 
 	keys, _ := suite.redisConfig.client.Keys(suite.redisConfig.ctx, "testkey*").Result()
 	expectedKeys := []string{"testkey1", "testkey2"}
@@ -144,15 +122,9 @@ func (suite *RedisConfigSuite) TestGetKeysCount() {
 	suite.redisConfig.Set("testkey2", []byte("testvalue2"), ttl)
 	suite.redisConfig.Set("otherkey", []byte("othervalue"), ttl)
 
-	count1, err := suite.redisConfig.CountQueriesWithPattern("testkey*")
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), 2, count1)
-	count2, err := suite.redisConfig.CountQueriesWithPattern("otherkey*")
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), 1, count2)
-	count3, err := suite.redisConfig.CountQueries()
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), int64(3), count3)
+	assert.Equal(suite.T(), 2, suite.redisConfig.CountQueriesWithPattern("testkey*"))
+	assert.Equal(suite.T(), 1, suite.redisConfig.CountQueriesWithPattern("otherkey*"))
+	assert.Equal(suite.T(), int64(3), suite.redisConfig.CountQueries())
 
 	suite.redisConfig.client.Del(suite.redisConfig.ctx, "testkey1", "testkey2", "otherkey")
 }

cache/redis/wrapper.go

@@ -1,104 +0,0 @@
-package libpack_cache_redis
-
-import (
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-// CacheWrapper wraps RedisConfig to implement the CacheClient interface
-// without returning errors, for backward compatibility
-type CacheWrapper struct {
-	redis  *RedisConfig
-	logger *libpack_logger.Logger
-}
-
-// NewCacheWrapper creates a new cache wrapper
-func NewCacheWrapper(config *RedisConfig, logger *libpack_logger.Logger) *CacheWrapper {
-	if logger == nil {
-		logger = &libpack_logger.Logger{}
-	}
-	return &CacheWrapper{
-		redis:  config,
-		logger: logger,
-	}
-}
-
-// Set stores a value with the given TTL
-func (w *CacheWrapper) Set(key string, value []byte, ttl time.Duration) {
-	if err := w.redis.Set(key, value, ttl); err != nil {
-		w.logger.Error(&libpack_logger.LogMessage{
-			Message: "Redis set error",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-				"key":   key,
-			},
-		})
-	}
-}
-
-// Get retrieves a value
-func (w *CacheWrapper) Get(key string) ([]byte, bool) {
-	value, found, err := w.redis.Get(key)
-	if err != nil {
-		w.logger.Error(&libpack_logger.LogMessage{
-			Message: "Redis get error",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-				"key":   key,
-			},
-		})
-		return nil, false
-	}
-	return value, found
-}
-
-// Delete removes a key
-func (w *CacheWrapper) Delete(key string) {
-	if err := w.redis.Delete(key); err != nil {
-		w.logger.Error(&libpack_logger.LogMessage{
-			Message: "Redis delete error",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-				"key":   key,
-			},
-		})
-	}
-}
-
-// Clear removes all keys
-func (w *CacheWrapper) Clear() {
-	if err := w.redis.Clear(); err != nil {
-		w.logger.Error(&libpack_logger.LogMessage{
-			Message: "Redis clear error",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-			},
-		})
-	}
-}
-
-// CountQueries returns the number of queries
-func (w *CacheWrapper) CountQueries() int64 {
-	count, err := w.redis.CountQueries()
-	if err != nil {
-		w.logger.Error(&libpack_logger.LogMessage{
-			Message: "Redis count queries error",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-			},
-		})
-		return 0
-	}
-	return count
-}
-
-// GetMemoryUsage returns 0 for Redis (not applicable)
-func (w *CacheWrapper) GetMemoryUsage() int64 {
-	return 0
-}
-
-// GetMaxMemorySize returns 0 for Redis (not applicable)
-func (w *CacheWrapper) GetMaxMemorySize() int64 {
-	return 0
-}

circuit_breaker_fallback_test.go

@@ -1,202 +0,0 @@
-package main
-
-import (
-	"errors"
-
-	"github.com/gofiber/fiber/v2"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-	"github.com/sony/gobreaker"
-	"github.com/stretchr/testify/assert"
-	"github.com/valyala/fasthttp"
-)
-
-// TestCircuitBreakerCacheFallback tests that when the circuit is open, the system
-// attempts to serve a cached response if available
-func (suite *CircuitBreakerTestSuite) TestCircuitBreakerCacheFallback() {
-	// Reset the buffer before the test
-	suite.outputBuffer.Reset()
-
-	// Initialize circuit breaker with a short timeout and cache fallback enabled
-	cfg.CircuitBreaker.MaxFailures = 3
-	cfg.CircuitBreaker.Timeout = 5
-	cfg.CircuitBreaker.ReturnCachedOnOpen = true
-	initCircuitBreaker(cfg)
-
-	// Create a test fiber app and context
-	app := fiber.New()
-	requestCtx := &fasthttp.RequestCtx{}
-	requestCtx.Request.SetRequestURI("/test-path")
-	requestCtx.Request.Header.SetMethod("POST")
-	requestCtx.Request.Header.SetContentType("application/json")
-	requestCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-	ctx := app.AcquireCtx(requestCtx)
-	defer app.ReleaseCtx(ctx)
-
-	// Calculate the cache key that would be used (with default user context since no auth headers)
-	// extractUserInfo() returns ("-", "-") when no auth is present
-	cacheKey := libpack_cache.CalculateHash(ctx, "-", "-")
-
-	// Add a test response to the cache
-	cachedResponse := []byte(`{"data":{"test":"cached-response"}}`)
-	libpack_cache.CacheStore(cacheKey, cachedResponse)
-
-	// Trip the circuit by generating failures
-	testErr := errors.New("test error")
-	for i := 0; i < cfg.CircuitBreaker.MaxFailures; i++ {
-		_, err := cb.Execute(func() (interface{}, error) {
-			return nil, testErr
-		})
-		assert.Error(suite.T(), err, "Execute should return error")
-	}
-
-	// Verify circuit is now open
-	assert.Equal(suite.T(), gobreaker.StateOpen.String(), cb.State().String(), "Circuit should be open after failures")
-
-	// Prepare to monitor metric increments for fallback success
-	initialFallbackSuccessCount := getMetricCount(libpack_monitoring.MetricsCircuitFallbackSuccess)
-	initialCacheHitCount := getMetricCount(libpack_monitoring.MetricsCacheHit)
-
-	// Simulate a proxy request that would hit the circuit breaker
-	err := performProxyRequest(ctx, "http://test-endpoint.example")
-
-	// The request should succeed since we have a cached response
-	assert.NoError(suite.T(), err, "Request should succeed with cached fallback")
-
-	// Verify cached response was served
-	assert.Equal(suite.T(), string(cachedResponse), string(ctx.Response().Body()),
-		"Response should match cached value")
-	assert.Equal(suite.T(), fiber.StatusOK, ctx.Response().StatusCode(),
-		"Status code should be 200 OK")
-
-	// Verify metrics were incremented
-	newFallbackSuccessCount := getMetricCount(libpack_monitoring.MetricsCircuitFallbackSuccess)
-	newCacheHitCount := getMetricCount(libpack_monitoring.MetricsCacheHit)
-
-	assert.True(suite.T(), newFallbackSuccessCount > initialFallbackSuccessCount,
-		"Circuit fallback success metric should be incremented")
-	assert.True(suite.T(), newCacheHitCount > initialCacheHitCount,
-		"Cache hit metric should be incremented")
-
-	// Verify log messages
-	assert.True(suite.T(), suite.logContains("Circuit open - serving from cache"),
-		"Log should indicate serving from cache")
-}
-
-// TestCircuitBreakerNoCacheFallback tests the case where the circuit is open but
-// no cached response is available
-func (suite *CircuitBreakerTestSuite) TestCircuitBreakerNoCacheFallback() {
-	// Reset the buffer before the test
-	suite.outputBuffer.Reset()
-
-	// Initialize circuit breaker with cache fallback enabled
-	cfg.CircuitBreaker.MaxFailures = 3
-	cfg.CircuitBreaker.Timeout = 5
-	cfg.CircuitBreaker.ReturnCachedOnOpen = true
-	initCircuitBreaker(cfg)
-
-	// Create a test fiber app and context
-	app := fiber.New()
-	requestCtx := &fasthttp.RequestCtx{}
-	requestCtx.Request.SetRequestURI("/test-path-no-cache")
-	requestCtx.Request.Header.SetMethod("POST")
-	requestCtx.Request.Header.SetContentType("application/json")
-	requestCtx.Request.SetBody([]byte(`{"query": "query { testNoCache }"}`))
-	ctx := app.AcquireCtx(requestCtx)
-	defer app.ReleaseCtx(ctx)
-
-	// Trip the circuit by generating failures
-	testErr := errors.New("test error")
-	for i := 0; i < cfg.CircuitBreaker.MaxFailures; i++ {
-		_, err := cb.Execute(func() (interface{}, error) {
-			return nil, testErr
-		})
-		assert.Error(suite.T(), err, "Execute should return error")
-	}
-
-	// Verify circuit is now open
-	assert.Equal(suite.T(), gobreaker.StateOpen.String(), cb.State().String(), "Circuit should be open after failures")
-
-	// Prepare to monitor metric increments for fallback failure
-	initialFallbackFailedCount := getMetricCount(libpack_monitoring.MetricsCircuitFallbackFailed)
-
-	// Simulate a proxy request that would hit the circuit breaker
-	err := performProxyRequest(ctx, "http://test-endpoint.example")
-
-	// The request should fail with ErrCircuitOpen
-	assert.Error(suite.T(), err, "Request should fail without cached fallback")
-	assert.Equal(suite.T(), ErrCircuitOpen.Error(), err.Error(), "Error should be ErrCircuitOpen")
-
-	// Verify metrics were incremented
-	newFallbackFailedCount := getMetricCount(libpack_monitoring.MetricsCircuitFallbackFailed)
-	assert.True(suite.T(), newFallbackFailedCount > initialFallbackFailedCount,
-		"Circuit fallback failed metric should be incremented")
-
-	// Verify log messages
-	assert.True(suite.T(), suite.logContains("Circuit open - no cached response available"),
-		"Log should indicate no cache available")
-}
-
-// TestCacheDisabledFallback tests that when ReturnCachedOnOpen is false,
-// no cache lookup is attempted
-func (suite *CircuitBreakerTestSuite) TestCacheDisabledFallback() {
-	// Reset the buffer before the test
-	suite.outputBuffer.Reset()
-
-	// Initialize circuit breaker with cache fallback disabled
-	cfg.CircuitBreaker.MaxFailures = 3
-	cfg.CircuitBreaker.Timeout = 5
-	cfg.CircuitBreaker.ReturnCachedOnOpen = false
-	initCircuitBreaker(cfg)
-
-	// Create a test fiber app and context
-	app := fiber.New()
-	requestCtx := &fasthttp.RequestCtx{}
-	requestCtx.Request.SetRequestURI("/test-path-cache-disabled")
-	requestCtx.Request.Header.SetMethod("POST")
-	requestCtx.Request.Header.SetContentType("application/json")
-	requestCtx.Request.SetBody([]byte(`{"query": "query { testCacheDisabled }"}`))
-	ctx := app.AcquireCtx(requestCtx)
-	defer app.ReleaseCtx(ctx)
-
-	// Calculate cache key and store a response (with default user context since no auth headers)
-	// extractUserInfo() returns ("-", "-") when no auth is present
-	cacheKey := libpack_cache.CalculateHash(ctx, "-", "-")
-	cachedResponse := []byte(`{"data":{"test":"cached-response"}}`)
-	libpack_cache.CacheStore(cacheKey, cachedResponse)
-
-	// Trip the circuit by generating failures
-	testErr := errors.New("test error")
-	for i := 0; i < cfg.CircuitBreaker.MaxFailures; i++ {
-		_, err := cb.Execute(func() (interface{}, error) {
-			return nil, testErr
-		})
-		assert.Error(suite.T(), err, "Execute should return error")
-	}
-
-	// Verify circuit is now open
-	assert.Equal(suite.T(), gobreaker.StateOpen.String(), cb.State().String(), "Circuit should be open")
-
-	// Simulate a proxy request that would hit the circuit breaker
-	err := performProxyRequest(ctx, "http://test-endpoint.example")
-
-	// The request should fail with ErrOpenState, not attempt cache fallback
-	assert.Error(suite.T(), err, "Request should fail when circuit is open and fallback disabled")
-	assert.Equal(suite.T(), gobreaker.ErrOpenState.Error(), err.Error(), "Error should be ErrOpenState")
-
-	// Verify no cache-related logs were generated
-	assert.False(suite.T(), suite.logContains("Circuit open - serving from cache"),
-		"Log should not indicate serving from cache")
-	assert.False(suite.T(), suite.logContains("Circuit open - no cached response available"),
-		"Log should not indicate attempting cache lookup")
-}
-
-// Helper function to get current metric count value
-func getMetricCount(metricName string) int {
-	counter := cfg.Monitoring.RegisterMetricsCounter(metricName, nil)
-	if counter == nil {
-		return 0
-	}
-	// Convert the counter value to int for easier comparison
-	return int(counter.Get())
-}

circuit_breaker_metrics.go

@@ -1,72 +0,0 @@
-package main
-
-import (
-	"sync/atomic"
-
-	"github.com/VictoriaMetrics/metrics"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-)
-
-// CircuitBreakerMetrics manages circuit breaker metrics without recreating gauges
-type CircuitBreakerMetrics struct {
-	stateValue   atomic.Value // stores float64
-	stateGauge   *metrics.Gauge
-	failCounters map[string]*metrics.Counter
-}
-
-// NewCircuitBreakerMetrics creates a new circuit breaker metrics manager
-func NewCircuitBreakerMetrics(monitoring *libpack_monitoring.MetricsSetup) *CircuitBreakerMetrics {
-	cbm := &CircuitBreakerMetrics{
-		failCounters: make(map[string]*metrics.Counter),
-	}
-
-	// Initialize state value
-	cbm.stateValue.Store(float64(0))
-
-	// Create gauge with callback that reads the atomic value on every scrape
-	// This ensures the metric always reflects the current circuit breaker state
-	cbm.stateGauge = monitoring.RegisterMetricsGaugeFunc(
-		libpack_monitoring.MetricsCircuitState,
-		nil,
-		func() float64 {
-			return cbm.GetState()
-		},
-	)
-
-	return cbm
-}
-
-// UpdateState updates the circuit breaker state value atomically
-func (cbm *CircuitBreakerMetrics) UpdateState(state float64) {
-	cbm.stateValue.Store(state)
-}
-
-// GetState returns the current circuit breaker state value
-func (cbm *CircuitBreakerMetrics) GetState() float64 {
-	if val := cbm.stateValue.Load(); val != nil {
-		return val.(float64)
-	}
-	return 0
-}
-
-// GetOrCreateFailCounter returns a counter for the given state key
-func (cbm *CircuitBreakerMetrics) GetOrCreateFailCounter(monitoring *libpack_monitoring.MetricsSetup, stateKey string) *metrics.Counter {
-	if counter, exists := cbm.failCounters[stateKey]; exists {
-		return counter
-	}
-
-	// Create new counter
-	counter := monitoring.RegisterMetricsCounter(stateKey, nil)
-	cbm.failCounters[stateKey] = counter
-	return counter
-}
-
-// Global circuit breaker metrics instance
-var cbMetrics *CircuitBreakerMetrics
-
-// InitializeCircuitBreakerMetrics initializes the global circuit breaker metrics
-func InitializeCircuitBreakerMetrics(monitoring *libpack_monitoring.MetricsSetup) {
-	if cbMetrics == nil {
-		cbMetrics = NewCircuitBreakerMetrics(monitoring)
-	}
-}

circuit_breaker_state_test.go

@@ -1,143 +0,0 @@
-package main
-
-import (
-	"errors"
-	"time"
-
-	"github.com/sony/gobreaker"
-	"github.com/stretchr/testify/assert"
-)
-
-// TestCircuitBreakerStateTransitions tests the circuit breaker state transitions:
-// Closed -> Open -> Half-Open -> Closed/Open
-func (suite *CircuitBreakerTestSuite) TestCircuitBreakerStateTransitions() {
-	// Reset the buffer before the test
-	suite.outputBuffer.Reset()
-
-	// Initialize circuit breaker with a shorter timeout for testing
-	cfg.CircuitBreaker.Timeout = 1 // 1 second timeout to half-open state
-	cfg.CircuitBreaker.MaxFailures = 3
-	initCircuitBreaker(cfg)
-
-	// 1. Initially the circuit should be closed
-	assert.Equal(suite.T(), gobreaker.StateClosed.String(), cb.State().String(), "Circuit should start in closed state")
-
-	// 2. Generate failures to trip the circuit
-	testErr := errors.New("test error")
-	for i := 0; i < cfg.CircuitBreaker.MaxFailures; i++ {
-		_, err := cb.Execute(func() (interface{}, error) {
-			return nil, testErr
-		})
-		assert.Error(suite.T(), err, "Execute should return error")
-	}
-
-	// 3. Circuit should now be open
-	assert.Equal(suite.T(), gobreaker.StateOpen.String(), cb.State().String(), "Circuit should transition to open state after failures")
-
-	// Verify that requests are rejected during open state
-	_, err := cb.Execute(func() (interface{}, error) {
-		return "success", nil
-	})
-	assert.Equal(suite.T(), gobreaker.ErrOpenState.Error(), err.Error(), "Should return ErrOpenState when circuit is open")
-
-	// Verify that the state change was logged
-	assert.True(suite.T(), suite.logContains("Circuit breaker state changed"),
-		"State change should be logged")
-	assert.True(suite.T(), suite.logContains(`"from":"closed"`),
-		"Log should mention transition from closed state")
-	assert.True(suite.T(), suite.logContains(`"to":"open"`),
-		"Log should mention transition to open state")
-
-	// 4. Wait for timeout to allow transition to half-open
-	time.Sleep(time.Duration(cfg.CircuitBreaker.Timeout+1) * time.Second)
-
-	// The next request should transition the circuit to half-open
-	// (Sony's gobreaker transitions to half-open on the next request after timeout)
-	tmpState := cb.State()
-	// Execute a successful request to check state
-	_, _ = cb.Execute(func() (interface{}, error) {
-		return "success", nil
-	})
-
-	// 5. Verify half-open state was reached
-	suite.T().Logf("Current circuit state: %s", cb.State())
-	if tmpState.String() != gobreaker.StateHalfOpen.String() {
-		suite.T().Skip("Circuit didn't transition to half-open as expected, likely due to timing issues in test environment")
-	}
-
-	// Verify the state change was logged
-	assert.True(suite.T(), suite.logContains(`"from":"open"`),
-		"Log should mention transition from open state")
-	assert.True(suite.T(), suite.logContains(`"to":"half-open"`),
-		"Log should mention transition to half-open state")
-
-	// 6. Execute successful requests in half-open state to transition back to closed
-	for i := 0; i < cfg.CircuitBreaker.MaxRequestsInHalfOpen; i++ {
-		_, err = cb.Execute(func() (interface{}, error) {
-			return "success", nil
-		})
-		assert.NoError(suite.T(), err, "Execute should not return error")
-	}
-
-	// 7. Circuit should now be closed again
-	assert.Equal(suite.T(), gobreaker.StateClosed.String(), cb.State().String(), "Circuit should transition to closed state after successes")
-
-	// Verify the final state change was logged
-	assert.True(suite.T(), suite.logContains(`"from":"half-open"`),
-		"Log should mention transition from half-open state")
-	assert.True(suite.T(), suite.logContains(`"to":"closed"`),
-		"Log should mention transition to closed state")
-}
-
-// TestCircuitBreakerHalfOpenToOpen tests that the circuit transitions from half-open to open
-// when failures occur during half-open state
-func (suite *CircuitBreakerTestSuite) TestCircuitBreakerHalfOpenToOpen() {
-	// Reset the buffer before the test
-	suite.outputBuffer.Reset()
-
-	// Initialize circuit breaker with a shorter timeout for testing
-	cfg.CircuitBreaker.Timeout = 1 // 1 second timeout to half-open state
-	cfg.CircuitBreaker.MaxFailures = 3
-	cfg.CircuitBreaker.MaxRequestsInHalfOpen = 2
-	initCircuitBreaker(cfg)
-
-	// 1. Generate failures to trip the circuit
-	testErr := errors.New("test error")
-	for i := 0; i < cfg.CircuitBreaker.MaxFailures; i++ {
-		_, err := cb.Execute(func() (interface{}, error) {
-			return nil, testErr
-		})
-		assert.Error(suite.T(), err, "Execute should return error")
-	}
-
-	// 2. Circuit should now be open
-	assert.Equal(suite.T(), gobreaker.StateOpen.String(), cb.State().String(), "Circuit should be open after failures")
-
-	// 3. Wait for timeout to allow transition to half-open
-	time.Sleep(time.Duration(cfg.CircuitBreaker.Timeout+1) * time.Second)
-
-	// The next request should transition the circuit to half-open
-	tmpState := cb.State()
-	// Try a request that will fail
-	_, _ = cb.Execute(func() (interface{}, error) {
-		return nil, testErr
-	})
-
-	// 4. If we successfully reached half-open state, verify it transitions back to open after failure
-	if tmpState.String() == gobreaker.StateHalfOpen.String() {
-		assert.Equal(suite.T(), gobreaker.StateOpen.String(), cb.State().String(),
-			"Circuit should transition back to open state after failure in half-open")
-
-		// Verify the state changes were logged
-		assert.True(suite.T(), suite.logContains(`"from":"open"`),
-			"Log should mention transition from open state")
-		assert.True(suite.T(), suite.logContains(`"to":"half-open"`),
-			"Log should mention transition to half-open state")
-		assert.True(suite.T(), suite.logContains(`"from":"half-open"`),
-			"Log should mention transition from half-open state")
-		assert.True(suite.T(), suite.logContains(`"to":"open"`),
-			"Log should mention transition back to open state")
-	} else {
-		suite.T().Skip("Circuit didn't transition to half-open as expected, likely due to timing issues in test environment")
-	}
-}

circuit_breaker_test.go

@@ -1,216 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"strings"
-	"testing"
-	"time"
-
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	libpack_cache_memory "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-	"github.com/sony/gobreaker"
-	"github.com/stretchr/testify/suite"
-)
-
-// CircuitBreakerTestSuite is a test suite for circuit breaker functionality
-type CircuitBreakerTestSuite struct {
-	suite.Suite
-	originalConfig *config
-	outputBuffer   *bytes.Buffer // Used to capture logger output
-}
-
-func (suite *CircuitBreakerTestSuite) SetupTest() {
-
-	// Store original config to restore later
-	suite.originalConfig = cfg
-
-	// Create a buffer to capture logger output
-	suite.outputBuffer = &bytes.Buffer{}
-
-	// Setup a new config with a real logger that writes to our buffer
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New().SetOutput(suite.outputBuffer)
-
-	// Initialize monitoring with a minimal configuration
-	cfg.Monitoring = libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{
-		PurgeOnCrawl: false,
-		PurgeEvery:   0,
-	})
-
-	// Configure circuit breaker settings
-	cfg.CircuitBreaker.Enable = true
-	cfg.CircuitBreaker.MaxFailures = 3
-	cfg.CircuitBreaker.Timeout = 5
-	cfg.CircuitBreaker.MaxRequestsInHalfOpen = 2
-	cfg.CircuitBreaker.ReturnCachedOnOpen = true
-	cfg.CircuitBreaker.TripOn5xx = true
-
-	// Initialize memory cache
-	memCache := libpack_cache_memory.New(time.Minute)
-	cacheConfig := &libpack_cache.CacheConfig{
-		Logger: cfg.Logger,
-		Client: memCache,
-		TTL:    60,
-	}
-	libpack_cache.EnableCache(cacheConfig)
-}
-
-func (suite *CircuitBreakerTestSuite) TearDownTest() {
-	// Restore original config
-	cfg = suite.originalConfig
-
-	// Reset circuit breaker and metrics
-	cbMutex.Lock()
-	defer cbMutex.Unlock()
-	cb = nil
-	// Circuit breaker metrics are now managed by cbMetrics
-	cbMetrics = nil
-}
-
-// Helper function to check if a specific message appears in the logger output
-func (suite *CircuitBreakerTestSuite) logContains(substring string) bool {
-	return strings.Contains(suite.outputBuffer.String(), substring)
-}
-
-// TestCreateTripFunc tests the circuit breaker trip function logic
-func (suite *CircuitBreakerTestSuite) TestCreateTripFunc() {
-	// Create the trip function
-	tripFunc := createTripFunc(cfg)
-
-	// Test cases
-	testCases := []struct {
-		name           string
-		counts         gobreaker.Counts
-		expectedResult bool
-	}{
-		{
-			name: "below threshold",
-			counts: gobreaker.Counts{
-				Requests:             10,
-				TotalSuccesses:       8,
-				TotalFailures:        2,
-				ConsecutiveSuccesses: 0,
-				ConsecutiveFailures:  2, // Below MaxFailures (3)
-			},
-			expectedResult: false,
-		},
-		{
-			name: "at threshold",
-			counts: gobreaker.Counts{
-				Requests:             10,
-				TotalSuccesses:       7,
-				TotalFailures:        3,
-				ConsecutiveSuccesses: 0,
-				ConsecutiveFailures:  3, // Equal to MaxFailures (3)
-			},
-			expectedResult: true,
-		},
-		{
-			name: "above threshold",
-			counts: gobreaker.Counts{
-				Requests:             10,
-				TotalSuccesses:       5,
-				TotalFailures:        5,
-				ConsecutiveSuccesses: 0,
-				ConsecutiveFailures:  5, // Above MaxFailures (3)
-			},
-			expectedResult: true,
-		},
-	}
-
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			// Reset the buffer before each test case
-			suite.outputBuffer.Reset()
-
-			// Test the trip function
-			result := tripFunc(tc.counts)
-			suite.Equal(tc.expectedResult, result, "Trip function result should match expected")
-
-			// If it should trip, verify that a warning log was generated
-			if tc.expectedResult {
-				suite.True(suite.logContains("Circuit breaker tripped"),
-					"Expected a warning log when circuit breaker trips")
-				suite.True(suite.logContains(fmt.Sprintf(`"consecutive_failures":%d`, tc.counts.ConsecutiveFailures)),
-					"Log should contain consecutive failures count")
-			}
-		})
-	}
-}
-
-// TestCreateStateChangeFunc tests the state change function logic
-func (suite *CircuitBreakerTestSuite) TestCreateStateChangeFunc() {
-	// We'll skip this test as it's problematic with the gauge callback issue
-	suite.T().Skip("Skipping due to gauge callback issues")
-}
-
-// TestCircuitBreakerInitialization tests the circuit breaker initialization
-func (suite *CircuitBreakerTestSuite) TestCircuitBreakerInitialization() {
-	// Reset the buffer before the test
-	suite.outputBuffer.Reset()
-
-	// Initialize circuit breaker
-	initCircuitBreaker(cfg)
-
-	// Verify circuit breaker was initialized
-	suite.NotNil(cb, "Circuit breaker should be initialized")
-	suite.NotNil(cbMetrics, "Circuit breaker metrics should be initialized")
-
-	// Verify the log message
-	suite.True(suite.logContains("Circuit breaker initialized"),
-		"Log should contain initialization message")
-
-	// Test with disabled circuit breaker
-	suite.outputBuffer.Reset()
-	cfg.CircuitBreaker.Enable = false
-
-	// Reset circuit breaker
-	cbMutex.Lock()
-	cb = nil
-	cbMetrics = nil
-	cbMutex.Unlock()
-
-	// Initialize again with disabled config
-	initCircuitBreaker(cfg)
-
-	// Verify circuit breaker was not initialized
-	suite.Nil(cb, "Circuit breaker should not be initialized when disabled")
-
-	// Verify the log message
-	suite.True(suite.logContains("Circuit breaker is disabled"),
-		"Log should contain disabled message")
-}
-
-// TestExecuteFunctionBehavior tests the basic behavior of Execute without circuit breaker
-func (suite *CircuitBreakerTestSuite) TestExecuteFunctionBehavior() {
-	// Reset for this test
-	cfg.CircuitBreaker.Enable = true
-	initCircuitBreaker(cfg)
-
-	// Test with success
-	result := "success"
-	execResult, err := cb.Execute(func() (interface{}, error) {
-		return result, nil
-	})
-
-	suite.NoError(err, "Execute should not return error on success")
-	suite.Equal(result, execResult, "Execute should return the correct result value")
-
-	// Test with error
-	testErr := errors.New("test error")
-	_, err = cb.Execute(func() (interface{}, error) {
-		return nil, testErr
-	})
-
-	suite.Error(err, "Execute should return error when function returns error")
-	suite.Equal(testErr.Error(), err.Error(), "Error message should match")
-}
-
-// Start the test suite
-func TestCircuitBreakerSuite(t *testing.T) {
-	suite.Run(t, new(CircuitBreakerTestSuite))
-}

config/config_test.go

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

connection_pool.go

@@ -1,319 +0,0 @@
-package main
-
-import (
-	"context"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/valyala/fasthttp"
-)
-
-// ConnectionPoolManager manages HTTP client connections
-type ConnectionPoolManager struct {
-	lastRecoveryAttempt   time.Time
-	ctx                   context.Context
-	client                *fasthttp.Client
-	cancel                context.CancelFunc
-	logger                *libpack_logging.Logger
-	cleanupInterval       time.Duration
-	keepAliveInterval     time.Duration
-	recoveryCheckInterval time.Duration
-	activeConnections     atomic.Int64
-	totalConnections      atomic.Int64
-	connectionFailures    atomic.Int64
-	mu                    sync.RWMutex
-	recoveryMutex         sync.Mutex
-}
-
-// NewConnectionPoolManager creates a new connection pool manager
-func NewConnectionPoolManager(client *fasthttp.Client) *ConnectionPoolManager {
-	ctx, cancel := context.WithCancel(context.Background())
-	cpm := &ConnectionPoolManager{
-		client:                client,
-		ctx:                   ctx,
-		cancel:                cancel,
-		keepAliveInterval:     45 * time.Second, // Reduced frequency to lower backend load
-		cleanupInterval:       30 * time.Second,
-		recoveryCheckInterval: 60 * time.Second,
-	}
-
-	// Set logger if available
-	if cfg != nil && cfg.Logger != nil {
-		cpm.logger = cfg.Logger
-	}
-
-	// Start periodic maintenance tasks
-	cpm.startPeriodicMaintenance()
-
-	return cpm
-}
-
-// startPeriodicMaintenance starts background maintenance tasks
-func (cpm *ConnectionPoolManager) startPeriodicMaintenance() {
-	// Start cleanup task
-	go cpm.runCleanupTask()
-
-	// Start keep-alive task
-	go cpm.runKeepAliveTask()
-
-	// Start recovery monitoring
-	go cpm.runRecoveryTask()
-}
-
-// runCleanupTask runs periodic connection cleanup
-func (cpm *ConnectionPoolManager) runCleanupTask() {
-	ticker := time.NewTicker(cpm.cleanupInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-cpm.ctx.Done():
-			return
-		case <-ticker.C:
-			cpm.cleanIdleConnections()
-		}
-	}
-}
-
-// runKeepAliveTask sends periodic keep-alive requests to maintain connections
-func (cpm *ConnectionPoolManager) runKeepAliveTask() {
-	ticker := time.NewTicker(cpm.keepAliveInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-cpm.ctx.Done():
-			return
-		case <-ticker.C:
-			cpm.performKeepAlive()
-		}
-	}
-}
-
-// runRecoveryTask monitors connection health and triggers recovery when needed
-func (cpm *ConnectionPoolManager) runRecoveryTask() {
-	ticker := time.NewTicker(cpm.recoveryCheckInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-cpm.ctx.Done():
-			return
-		case <-ticker.C:
-			cpm.checkAndRecover()
-		}
-	}
-}
-
-// cleanIdleConnections closes idle connections
-func (cpm *ConnectionPoolManager) cleanIdleConnections() {
-	cpm.mu.Lock()
-	defer cpm.mu.Unlock()
-
-	if cpm.client != nil {
-		cpm.client.CloseIdleConnections()
-		if cpm.logger != nil {
-			cpm.logger.Debug(&libpack_logging.LogMessage{
-				Message: "Cleaned idle HTTP connections",
-				Pairs: map[string]interface{}{
-					"active_connections": cpm.activeConnections.Load(),
-					"total_connections":  cpm.totalConnections.Load(),
-				},
-			})
-		}
-	}
-}
-
-// performKeepAlive sends a lightweight request to keep connections alive
-func (cpm *ConnectionPoolManager) performKeepAlive() {
-	if cpm.client == nil {
-		return
-	}
-
-	// Only perform keep-alive if we have a backend URL configured
-	if cfg == nil || cfg.Server.HostGraphQL == "" {
-		return
-	}
-
-	// Skip keep-alive if we have recent successful connections
-	// This reduces unnecessary load when the system is actively processing requests
-	if cpm.connectionFailures.Load() == 0 && cpm.totalConnections.Load() > 0 {
-		// No recent failures and we have active connections, skip this keep-alive
-		return
-	}
-
-	// Use HEAD request for minimal overhead
-	req := fasthttp.AcquireRequest()
-	resp := fasthttp.AcquireResponse()
-	defer fasthttp.ReleaseRequest(req)
-	defer fasthttp.ReleaseResponse(resp)
-
-	// Try to use health check endpoint if available, otherwise use base URL
-	healthURL := cfg.Server.HealthcheckGraphQL
-	if healthURL == "" {
-		// Use base URL with proper path separator
-		baseURL := cfg.Server.HostGraphQL
-		if !strings.HasSuffix(baseURL, "/") {
-			baseURL += "/"
-		}
-		healthURL = baseURL + "healthz"
-	}
-
-	req.SetRequestURI(healthURL)
-	req.Header.SetMethod("HEAD") // HEAD is lighter than POST with body
-
-	// Short timeout for keep-alive
-	err := cpm.client.DoTimeout(req, resp, 3*time.Second)
-	if err != nil {
-		cpm.connectionFailures.Add(1)
-		if cpm.logger != nil {
-			cpm.logger.Debug(&libpack_logging.LogMessage{
-				Message: "Keep-alive request failed",
-				Pairs: map[string]interface{}{
-					"error": err.Error(),
-				},
-			})
-		}
-	} else {
-		// Reset failure count on success
-		cpm.connectionFailures.Store(0)
-	}
-}
-
-// checkAndRecover monitors connection health and performs recovery if needed
-func (cpm *ConnectionPoolManager) checkAndRecover() {
-	cpm.recoveryMutex.Lock()
-	defer cpm.recoveryMutex.Unlock()
-
-	failures := cpm.connectionFailures.Load()
-
-	// If we have too many failures, trigger recovery
-	if failures > 5 {
-		// Don't attempt recovery too frequently
-		if time.Since(cpm.lastRecoveryAttempt) < 30*time.Second {
-			return
-		}
-
-		cpm.lastRecoveryAttempt = time.Now()
-
-		if cpm.logger != nil {
-			cpm.logger.Warning(&libpack_logging.LogMessage{
-				Message: "Connection pool health degraded, attempting recovery",
-				Pairs: map[string]interface{}{
-					"consecutive_failures": failures,
-				},
-			})
-		}
-
-		cpm.performRecovery()
-	}
-}
-
-// performRecovery attempts to recover the connection pool
-func (cpm *ConnectionPoolManager) performRecovery() {
-	cpm.mu.Lock()
-	defer cpm.mu.Unlock()
-
-	if cpm.client != nil {
-		// Close all idle connections to force new ones
-		cpm.client.CloseIdleConnections()
-
-		// Reset failure counter
-		cpm.connectionFailures.Store(0)
-
-		if cpm.logger != nil {
-			cpm.logger.Info(&libpack_logging.LogMessage{
-				Message: "Connection pool recovery completed",
-			})
-		}
-	}
-}
-
-// RecordConnectionSuccess records a successful connection
-func (cpm *ConnectionPoolManager) RecordConnectionSuccess() {
-	cpm.activeConnections.Add(1)
-	cpm.totalConnections.Add(1)
-	// Reset failures on success
-	cpm.connectionFailures.Store(0)
-}
-
-// RecordConnectionFailure records a failed connection
-func (cpm *ConnectionPoolManager) RecordConnectionFailure() {
-	cpm.connectionFailures.Add(1)
-}
-
-// GetConnectionStats returns current connection statistics
-func (cpm *ConnectionPoolManager) GetConnectionStats() map[string]interface{} {
-	return map[string]interface{}{
-		"active_connections":    cpm.activeConnections.Load(),
-		"total_connections":     cpm.totalConnections.Load(),
-		"connection_failures":   cpm.connectionFailures.Load(),
-		"last_recovery_attempt": cpm.lastRecoveryAttempt,
-	}
-}
-
-// GetClient returns the HTTP client
-func (cpm *ConnectionPoolManager) GetClient() *fasthttp.Client {
-	cpm.mu.RLock()
-	defer cpm.mu.RUnlock()
-	return cpm.client
-}
-
-// Shutdown gracefully shuts down the connection pool
-func (cpm *ConnectionPoolManager) Shutdown() error {
-	if cpm == nil {
-		return nil
-	}
-
-	cpm.cancel()
-
-	cpm.mu.Lock()
-	defer cpm.mu.Unlock()
-
-	if cpm.client != nil {
-		cpm.client.CloseIdleConnections()
-		if cfg != nil && cfg.Logger != nil {
-			cfg.Logger.Info(&libpack_logging.LogMessage{
-				Message: "HTTP connection pool shut down",
-			})
-		}
-	}
-
-	return nil
-}
-
-// Global connection pool manager
-var (
-	connectionPoolManager *ConnectionPoolManager
-	connectionPoolMutex   sync.RWMutex
-)
-
-// InitializeConnectionPool initializes the global connection pool
-func InitializeConnectionPool(client *fasthttp.Client) {
-	connectionPoolMutex.Lock()
-	defer connectionPoolMutex.Unlock()
-	if connectionPoolManager != nil {
-		connectionPoolManager.Shutdown()
-	}
-	connectionPoolManager = NewConnectionPoolManager(client)
-}
-
-// ShutdownConnectionPool safely shuts down the global connection pool
-func ShutdownConnectionPool() {
-	connectionPoolMutex.Lock()
-	defer connectionPoolMutex.Unlock()
-	if connectionPoolManager != nil {
-		connectionPoolManager.Shutdown()
-		connectionPoolManager = nil
-	}
-}
-
-// GetConnectionPoolManager returns the global connection pool manager
-func GetConnectionPoolManager() *ConnectionPoolManager {
-	connectionPoolMutex.RLock()
-	defer connectionPoolMutex.RUnlock()
-	return connectionPoolManager
-}

connection_pool_test.go

@@ -1,334 +0,0 @@
-package main
-
-import (
-	"sync"
-	"testing"
-	"time"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-	"github.com/valyala/fasthttp"
-)
-
-type ConnectionPoolTestSuite struct {
-	suite.Suite
-	origCfg               *config
-	origConnectionManager *ConnectionPoolManager
-}
-
-func TestConnectionPoolTestSuite(t *testing.T) {
-	suite.Run(t, new(ConnectionPoolTestSuite))
-}
-
-func (suite *ConnectionPoolTestSuite) SetupTest() {
-	suite.origCfg = cfg
-	cfg = &config{
-		Logger: libpack_logging.New(),
-	}
-	suite.origConnectionManager = connectionPoolManager
-	connectionPoolManager = nil
-}
-
-func (suite *ConnectionPoolTestSuite) TearDownTest() {
-	if connectionPoolManager != nil {
-		connectionPoolManager.Shutdown()
-		connectionPoolManager = nil
-	}
-	cfg = suite.origCfg
-	connectionPoolManager = suite.origConnectionManager
-}
-
-func (suite *ConnectionPoolTestSuite) TestNewConnectionPoolManager() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	assert.NotNil(suite.T(), cpm)
-	assert.NotNil(suite.T(), cpm.client)
-	assert.NotNil(suite.T(), cpm.ctx)
-	assert.NotNil(suite.T(), cpm.cancel)
-
-	// Cleanup
-	cpm.Shutdown()
-}
-
-func (suite *ConnectionPoolTestSuite) TestGetClient() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	defer cpm.Shutdown()
-
-	retrievedClient := cpm.GetClient()
-	assert.Equal(suite.T(), client, retrievedClient)
-}
-
-func (suite *ConnectionPoolTestSuite) TestShutdown() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-
-	// Shutdown should be safe
-	err := cpm.Shutdown()
-	assert.NoError(suite.T(), err)
-
-	// Multiple shutdowns should be safe
-	err = cpm.Shutdown()
-	assert.NoError(suite.T(), err)
-}
-
-func (suite *ConnectionPoolTestSuite) TestShutdownNil() {
-	var cpm *ConnectionPoolManager
-	err := cpm.Shutdown()
-	assert.NoError(suite.T(), err)
-}
-
-func (suite *ConnectionPoolTestSuite) TestPeriodicCleanup() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-
-	// Let the cleanup goroutine run
-	time.Sleep(50 * time.Millisecond)
-
-	// Shutdown should stop the cleanup goroutine
-	err := cpm.Shutdown()
-	assert.NoError(suite.T(), err)
-}
-
-func (suite *ConnectionPoolTestSuite) TestCleanIdleConnections() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	defer cpm.Shutdown()
-
-	// Manually trigger cleanup
-	cpm.cleanIdleConnections()
-
-	// Should not panic or error
-	assert.NotNil(suite.T(), cpm.client)
-}
-
-func (suite *ConnectionPoolTestSuite) TestConcurrentAccess() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	defer cpm.Shutdown()
-
-	var wg sync.WaitGroup
-
-	// Concurrent reads
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				c := cpm.GetClient()
-				assert.NotNil(suite.T(), c)
-				time.Sleep(time.Microsecond)
-			}
-		}()
-	}
-
-	// Concurrent cleanups
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 10; j++ {
-				cpm.cleanIdleConnections()
-				time.Sleep(time.Millisecond)
-			}
-		}()
-	}
-
-	wg.Wait()
-}
-
-func (suite *ConnectionPoolTestSuite) TestInitializeConnectionPool() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 200,
-	}
-
-	InitializeConnectionPool(client)
-	assert.NotNil(suite.T(), connectionPoolManager)
-	assert.Equal(suite.T(), client, connectionPoolManager.GetClient())
-
-	// Initialize again should replace the old one
-	newClient := &fasthttp.Client{
-		MaxConnsPerHost: 300,
-	}
-	InitializeConnectionPool(newClient)
-	assert.Equal(suite.T(), newClient, connectionPoolManager.GetClient())
-}
-
-func (suite *ConnectionPoolTestSuite) TestShutdownConnectionPool() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	InitializeConnectionPool(client)
-	assert.NotNil(suite.T(), connectionPoolManager)
-
-	ShutdownConnectionPool()
-	assert.Nil(suite.T(), connectionPoolManager)
-
-	// Shutdown again should be safe
-	ShutdownConnectionPool()
-	assert.Nil(suite.T(), connectionPoolManager)
-}
-
-func (suite *ConnectionPoolTestSuite) TestGetConnectionPoolManager() {
-	assert.Nil(suite.T(), GetConnectionPoolManager())
-
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-	InitializeConnectionPool(client)
-
-	manager := GetConnectionPoolManager()
-	assert.NotNil(suite.T(), manager)
-	assert.Equal(suite.T(), connectionPoolManager, manager)
-
-	ShutdownConnectionPool()
-	assert.Nil(suite.T(), GetConnectionPoolManager())
-}
-
-func (suite *ConnectionPoolTestSuite) TestContextCancellation() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-
-	// Cancel the context
-	cpm.cancel()
-
-	// Give the cleanup goroutine time to exit
-	time.Sleep(50 * time.Millisecond)
-
-	// Shutdown should still work
-	err := cpm.Shutdown()
-	assert.NoError(suite.T(), err)
-}
-
-func (suite *ConnectionPoolTestSuite) TestRaceConditions() {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	var wg sync.WaitGroup
-
-	// Concurrent initialization and shutdown
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			InitializeConnectionPool(client)
-		}()
-	}
-
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			time.Sleep(time.Microsecond)
-			ShutdownConnectionPool()
-		}()
-	}
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			manager := GetConnectionPoolManager()
-			if manager != nil {
-				_ = manager.GetClient()
-			}
-		}()
-	}
-
-	wg.Wait()
-}
-
-func (suite *ConnectionPoolTestSuite) TestCleanupWithNilLogger() {
-	// Test cleanup when cfg or logger is nil
-	origCfg := cfg
-	cfg = nil
-
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-
-	// Should not panic
-	cpm.cleanIdleConnections()
-	err := cpm.Shutdown()
-	assert.NoError(suite.T(), err)
-
-	cfg = origCfg
-}
-
-func (suite *ConnectionPoolTestSuite) TestMemoryManagement() {
-	// Test that connection pool properly manages memory
-	client := &fasthttp.Client{
-		MaxConnsPerHost:     10,
-		MaxIdleConnDuration: 100 * time.Millisecond,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	defer cpm.Shutdown()
-
-	// Simulate connections being created and becoming idle
-	// The periodic cleanup should handle them
-	time.Sleep(150 * time.Millisecond)
-
-	// Manual cleanup to ensure connections are released
-	cpm.cleanIdleConnections()
-
-	// Verify client is still accessible
-	assert.NotNil(suite.T(), cpm.GetClient())
-}
-
-// Benchmark tests
-func BenchmarkConnectionPoolGetClient(b *testing.B) {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	defer cpm.Shutdown()
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			_ = cpm.GetClient()
-		}
-	})
-}
-
-func BenchmarkConnectionPoolCleanup(b *testing.B) {
-	client := &fasthttp.Client{
-		MaxConnsPerHost: 100,
-	}
-
-	cpm := NewConnectionPoolManager(client)
-	defer cpm.Shutdown()
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		cpm.cleanIdleConnections()
-	}
-}

connection_resilience_test.go

@@ -1,263 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"net/http"
-	"net/http/httptest"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/suite"
-)
-
-// ConnectionResilienceTestSuite tests connection resilience features
-type ConnectionResilienceTestSuite struct {
-	suite.Suite
-	originalConfig   *config
-	outputBuffer     *bytes.Buffer
-	mockServer       *httptest.Server
-	mockServerCalled atomic.Int32
-}
-
-func (suite *ConnectionResilienceTestSuite) SetupTest() {
-	// Store original config
-	suite.originalConfig = cfg
-
-	// Create a buffer to capture logger output
-	suite.outputBuffer = &bytes.Buffer{}
-
-	// Setup a new config with a real logger that writes to our buffer
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New().SetOutput(suite.outputBuffer)
-
-	// Reset call counter
-	suite.mockServerCalled.Store(0)
-
-	// Create a mock GraphQL server
-	suite.mockServer = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		suite.mockServerCalled.Add(1)
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte(`{"data":{"__typename":"Query"}}`))
-	}))
-
-	// Configure the test with mock server URL
-	cfg.Server.HostGraphQL = suite.mockServer.URL
-	cfg.Client.ClientTimeout = 5
-	cfg.Client.MaxConnsPerHost = 10
-	cfg.Client.MaxIdleConnDuration = 30
-	cfg.Client.DisableTLSVerify = true
-
-	// Create fasthttp client
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-}
-
-func (suite *ConnectionResilienceTestSuite) TearDownTest() {
-	// Close mock server
-	if suite.mockServer != nil {
-		suite.mockServer.Close()
-	}
-
-	// Clean up global instances with proper shutdown
-	if backendHealthManager != nil {
-		backendHealthManager.Shutdown()
-		backendHealthManager = nil
-	}
-
-	if connectionPoolManager != nil {
-		connectionPoolManager.Shutdown()
-		connectionPoolManager = nil
-	}
-
-	// Restore original config
-	cfg = suite.originalConfig
-}
-
-// TestBackendHealthManager tests the backend health monitoring
-func (suite *ConnectionResilienceTestSuite) TestBackendHealthManager() {
-	suite.Run("initialization", func() {
-		healthMgr := NewBackendHealthManager(cfg.Client.FastProxyClient, cfg.Server.HostGraphQL, cfg.Logger)
-		suite.NotNil(healthMgr)
-		suite.Equal(cfg.Server.HostGraphQL, healthMgr.backendURL)
-		suite.Equal(5*time.Second, healthMgr.checkInterval)
-		suite.Equal(30, healthMgr.maxRetries)
-	})
-
-	suite.Run("health check success", func() {
-		healthMgr := NewBackendHealthManager(cfg.Client.FastProxyClient, cfg.Server.HostGraphQL, cfg.Logger)
-		isHealthy := healthMgr.checkBackendHealth()
-		suite.True(isHealthy)
-		suite.GreaterOrEqual(suite.mockServerCalled.Load(), int32(1))
-	})
-
-	suite.Run("health check failure", func() {
-		// Use invalid URL to simulate failure
-		healthMgr := NewBackendHealthManager(cfg.Client.FastProxyClient, "http://invalid-url:99999", cfg.Logger)
-		isHealthy := healthMgr.checkBackendHealth()
-		suite.False(isHealthy)
-	})
-
-	suite.Run("startup readiness with healthy backend", func() {
-		healthMgr := NewBackendHealthManager(cfg.Client.FastProxyClient, cfg.Server.HostGraphQL, cfg.Logger)
-		err := healthMgr.WaitForBackendReady(10 * time.Second)
-		suite.NoError(err)
-		suite.True(healthMgr.IsHealthy())
-	})
-
-	suite.Run("startup readiness timeout", func() {
-		// Use invalid URL to simulate backend not ready
-		healthMgr := NewBackendHealthManager(cfg.Client.FastProxyClient, "http://invalid-url:99999", cfg.Logger)
-		err := healthMgr.WaitForBackendReady(2 * time.Second)
-		suite.Error(err)
-		suite.Contains(err.Error(), "did not become ready")
-	})
-}
-
-// TestConnectionPoolManager tests the connection pool management
-func (suite *ConnectionResilienceTestSuite) TestConnectionPoolManager() {
-	suite.Run("initialization", func() {
-		poolMgr := NewConnectionPoolManager(cfg.Client.FastProxyClient)
-		suite.NotNil(poolMgr)
-		suite.NotNil(poolMgr.client)
-		suite.Equal(45*time.Second, poolMgr.keepAliveInterval) // Updated from 15s to 45s for lower backend load
-		suite.Equal(30*time.Second, poolMgr.cleanupInterval)
-		suite.Equal(60*time.Second, poolMgr.recoveryCheckInterval)
-	})
-
-	suite.Run("connection statistics", func() {
-		poolMgr := NewConnectionPoolManager(cfg.Client.FastProxyClient)
-
-		// Record some connections
-		poolMgr.RecordConnectionSuccess()
-		poolMgr.RecordConnectionSuccess()
-		poolMgr.RecordConnectionFailure()
-
-		stats := poolMgr.GetConnectionStats()
-		suite.Equal(int64(2), stats["active_connections"])
-		suite.Equal(int64(2), stats["total_connections"])
-		suite.Equal(int64(1), stats["connection_failures"])
-	})
-
-	suite.Run("keep alive functionality", func() {
-		poolMgr := NewConnectionPoolManager(cfg.Client.FastProxyClient)
-		poolMgr.logger = cfg.Logger
-
-		// With the optimized keep-alive, it skips when no failures and connections exist
-		// So we first record a failure to force keep-alive to execute
-		poolMgr.RecordConnectionFailure()
-
-		// Test keep-alive with valid backend
-		poolMgr.performKeepAlive()
-
-		// Should have made a request to the mock server
-		suite.GreaterOrEqual(suite.mockServerCalled.Load(), int32(1))
-	})
-
-	suite.Run("recovery mechanism", func() {
-		poolMgr := NewConnectionPoolManager(cfg.Client.FastProxyClient)
-		poolMgr.logger = cfg.Logger
-
-		// Simulate many failures to trigger recovery
-		for i := 0; i < 10; i++ {
-			poolMgr.RecordConnectionFailure()
-		}
-
-		// Check recovery triggers
-		poolMgr.checkAndRecover()
-
-		// Verify failure count was reset
-		stats := poolMgr.GetConnectionStats()
-		suite.Equal(int64(0), stats["connection_failures"])
-	})
-}
-
-// TestIntegratedHealthManagement tests integration between health manager and connection pool
-func (suite *ConnectionResilienceTestSuite) TestIntegratedHealthManagement() {
-	suite.Run("global initialization", func() {
-		// Initialize global instances
-		healthMgr := InitializeBackendHealth(cfg.Client.FastProxyClient, cfg.Server.HostGraphQL, cfg.Logger)
-		poolMgr := NewConnectionPoolManager(cfg.Client.FastProxyClient)
-
-		// Set global instances
-		backendHealthManager = healthMgr
-		connectionPoolManager = poolMgr
-
-		// Test global access
-		suite.Equal(healthMgr, GetBackendHealthManager())
-		suite.Equal(poolMgr, GetConnectionPoolManager())
-	})
-
-	suite.Run("health manager startup", func() {
-		healthMgr := InitializeBackendHealth(cfg.Client.FastProxyClient, cfg.Server.HostGraphQL, cfg.Logger)
-		backendHealthManager = healthMgr
-
-		// Start health checking
-		healthMgr.StartHealthChecking()
-
-		// Wait for backend to be ready
-		err := healthMgr.WaitForBackendReady(10 * time.Second)
-		suite.NoError(err)
-
-		// Give some time for health checks to run
-		time.Sleep(100 * time.Millisecond)
-
-		// Verify health status
-		suite.True(healthMgr.IsHealthy())
-		suite.Equal(int32(0), healthMgr.GetConsecutiveFailures())
-	})
-}
-
-// TestConnectionErrorDetection tests connection error detection
-func (suite *ConnectionResilienceTestSuite) TestConnectionErrorDetection() {
-	testCases := []struct {
-		name     string
-		errorMsg string
-		expected bool
-	}{
-		{"connection refused", "connection refused", true},
-		{"connection reset", "connection reset by peer", true},
-		{"no route to host", "no route to host", true},
-		{"network unreachable", "network is unreachable", true},
-		{"broken pipe", "broken pipe", true},
-		{"EOF", "EOF", true},
-		{"dial tcp", "dial tcp 127.0.0.1:99999: connect: connection refused", true},
-		{"regular error", "some other error", false},
-		{"timeout error", "timeout exceeded", false},
-	}
-
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			fakeErr := &mockError{msg: tc.errorMsg}
-			isConn := isConnectionError(fakeErr)
-			suite.Equal(tc.expected, isConn)
-		})
-	}
-}
-
-// mockError is a simple error implementation for testing
-type mockError struct {
-	msg string
-}
-
-func (e *mockError) Error() string {
-	return e.msg
-}
-
-// TestRetryLogic tests the enhanced retry mechanism
-func (suite *ConnectionResilienceTestSuite) TestRetryLogic() {
-	suite.Run("connection error classification", func() {
-		// Test that connection errors are properly identified
-		connErr := &mockError{msg: "connection refused"}
-		suite.True(isConnectionError(connErr))
-
-		timeoutErr := &mockError{msg: "timeout exceeded"}
-		suite.False(isConnectionError(timeoutErr))
-	})
-}
-
-// Start the test suite
-func TestConnectionResilienceSuite(t *testing.T) {
-	suite.Run(t, new(ConnectionResilienceTestSuite))
-}

debug_routing.go

@@ -1,143 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-
-	fiber "github.com/gofiber/fiber/v2"
-	"github.com/graphql-go/graphql/language/ast"
-	"github.com/graphql-go/graphql/language/parser"
-	"github.com/graphql-go/graphql/language/source"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-// debugParseGraphQLQuery provides detailed logging for mutation routing analysis
-// This is automatically called when LOG_LEVEL=DEBUG to help identify routing issues
-//
-// It logs:
-//   - GraphQL query structure (operations, selections, directives)
-//   - Final routing decision (which endpoint was chosen)
-//   - Automatic detection of mutations routed to wrong endpoints
-//
-// To enable: Set LOG_LEVEL=DEBUG and restart the proxy
-func debugParseGraphQLQuery(c *fiber.Ctx, query string) {
-	if cfg == nil || cfg.Logger == nil {
-		return
-	}
-
-	cfg.Logger.Info(&libpack_logger.LogMessage{
-		Message: "=== DEBUG: Parsing GraphQL Query ===",
-		Pairs: map[string]interface{}{
-			"query_length":  len(query),
-			"query_preview": truncateString(query, 100),
-		},
-	})
-
-	// Parse the query
-	src := source.NewSource(&source.Source{
-		Body: []byte(query),
-		Name: "Debug GraphQL request",
-	})
-
-	p, err := parser.Parse(parser.ParseParams{Source: src})
-	if err != nil {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "DEBUG: Failed to parse query",
-			Pairs:   map[string]interface{}{"error": err.Error()},
-		})
-		return
-	}
-
-	cfg.Logger.Info(&libpack_logger.LogMessage{
-		Message: "DEBUG: Query parsed successfully",
-		Pairs: map[string]interface{}{
-			"definitions_count": len(p.Definitions),
-		},
-	})
-
-	// Analyze each definition
-	for i, d := range p.Definitions {
-		if oper, ok := d.(*ast.OperationDefinition); ok {
-			operationType := strings.ToLower(oper.Operation)
-			operationName := "unnamed"
-			if oper.Name != nil {
-				operationName = oper.Name.Value
-			}
-
-			// Count selections
-			selectionCount := 0
-			if oper.SelectionSet != nil {
-				selectionCount = len(oper.GetSelectionSet().Selections)
-			}
-
-			cfg.Logger.Info(&libpack_logger.LogMessage{
-				Message: fmt.Sprintf("DEBUG: Definition #%d (OperationDefinition)", i),
-				Pairs: map[string]interface{}{
-					"operation_type":  operationType,
-					"operation_name":  operationName,
-					"selection_count": selectionCount,
-					"is_mutation":     operationType == "mutation",
-					"directive_count": len(oper.Directives),
-				},
-			})
-
-			// Log selections for mutations
-			if operationType == "mutation" && oper.SelectionSet != nil {
-				for j, sel := range oper.GetSelectionSet().Selections {
-					if field, ok := sel.(*ast.Field); ok {
-						cfg.Logger.Info(&libpack_logger.LogMessage{
-							Message: fmt.Sprintf("DEBUG: Mutation field #%d", j),
-							Pairs: map[string]interface{}{
-								"field_name": field.Name.Value,
-							},
-						})
-					}
-				}
-			}
-		} else if frag, ok := d.(*ast.FragmentDefinition); ok {
-			cfg.Logger.Info(&libpack_logger.LogMessage{
-				Message: fmt.Sprintf("DEBUG: Definition #%d (FragmentDefinition)", i),
-				Pairs: map[string]interface{}{
-					"fragment_name": frag.Name.Value,
-				},
-			})
-		}
-	}
-
-	// Now run the actual parsing to see the result
-	result := parseGraphQLQuery(c)
-
-	cfg.Logger.Info(&libpack_logger.LogMessage{
-		Message: "DEBUG: Final routing decision",
-		Pairs: map[string]interface{}{
-			"operation_type":  result.operationType,
-			"operation_name":  result.operationName,
-			"active_endpoint": result.activeEndpoint,
-			"should_block":    result.shouldBlock,
-			"should_ignore":   result.shouldIgnore,
-			"write_endpoint":  cfg.Server.HostGraphQL,
-			"read_endpoint":   cfg.Server.HostGraphQLReadOnly,
-			"is_using_write":  result.activeEndpoint == cfg.Server.HostGraphQL,
-		},
-	})
-
-	// Check for potential issues
-	if result.operationType == "mutation" && result.activeEndpoint != cfg.Server.HostGraphQL {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "DEBUG: ⚠️  BUG DETECTED: Mutation routed to wrong endpoint!",
-			Pairs: map[string]interface{}{
-				"expected_endpoint": cfg.Server.HostGraphQL,
-				"actual_endpoint":   result.activeEndpoint,
-			},
-		})
-	}
-
-	if result.operationType == "mutation" && strings.Contains(strings.ToLower(result.activeEndpoint), "read") {
-		cfg.Logger.Error(&libpack_logger.LogMessage{
-			Message: "DEBUG: ⚠️  CRITICAL: Mutation endpoint contains 'read' in URL!",
-			Pairs: map[string]interface{}{
-				"endpoint": result.activeEndpoint,
-			},
-		})
-	}
-}

details.go

@@ -20,19 +20,19 @@ func extractClaimsFromJWTHeader(authorization string) (usr, role string) {
 
 	tokenParts := strings.SplitN(authorization, ".", 3)
 	if len(tokenParts) != 3 {
-		handleError("Can't split the token", map[string]interface{}{"token": maskToken(authorization)})
+		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": maskToken(authorization)})
+		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": maskToken(authorization)})
+		handleError("Can't unmarshal the claim", map[string]interface{}{"token": authorization})
 		return
 	}
 
@@ -47,69 +47,15 @@ func extractClaim(claimMap map[string]interface{}, claimPath, name string) strin
 		return defaultValue
 	}
 
-	// Validate claim path to prevent injection attacks
-	if !isValidClaimPath(claimPath) {
-		handleError(fmt.Sprintf("Invalid claim path for %s", name), map[string]interface{}{"path": claimPath})
-		return defaultValue
-	}
-
 	value, ok := ask.For(claimMap, claimPath).String(defaultValue)
 	if !ok {
-		handleError(fmt.Sprintf("Can't find the %s", name), map[string]interface{}{"claim_map": sanitizeClaimMap(claimMap), "path": claimPath})
+		handleError(fmt.Sprintf("Can't find the %s", name), map[string]interface{}{"claim_map": claimMap, "path": claimPath})
 		return defaultValue
 	}
 
 	return value
 }
 
-// maskToken masks JWT tokens in logs to prevent exposure
-func maskToken(token string) string {
-	if len(token) <= 10 {
-		return "***"
-	}
-	return token[:4] + "***" + token[len(token)-4:]
-}
-
-// isValidClaimPath validates JWT claim paths to prevent injection
-func isValidClaimPath(path string) bool {
-	if path == "" {
-		return false
-	}
-	// Allow only alphanumeric characters, dots, underscores, and hyphens
-	for _, char := range path {
-		if (char < 'a' || char > 'z') &&
-			(char < 'A' || char > 'Z') &&
-			(char < '0' || char > '9') &&
-			char != '.' && char != '_' && char != '-' {
-			return false
-		}
-	}
-	// Prevent path traversal attempts
-	if strings.Contains(path, "..") || strings.Contains(path, "//") {
-		return false
-	}
-	return true
-}
-
-// sanitizeClaimMap removes sensitive data from claim map for logging
-func sanitizeClaimMap(claimMap map[string]interface{}) map[string]interface{} {
-	sanitized := make(map[string]interface{})
-	sensitiveKeys := map[string]bool{
-		"password": true, "secret": true, "token": true, "key": true,
-		"auth": true, "credential": true, "private": true,
-	}
-
-	for k, v := range claimMap {
-		lowerKey := strings.ToLower(k)
-		if sensitiveKeys[lowerKey] {
-			sanitized[k] = "***"
-		} else {
-			sanitized[k] = v
-		}
-	}
-	return sanitized
-}
-
 func handleError(msg string, details map[string]interface{}) {
 	cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, emptyMetrics)
 	cfg.Logger.Error(&libpack_logger.LogMessage{

details_test.go

@@ -74,8 +74,8 @@ func (suite *Tests) Test_extractClaimsFromJWTHeader() {
 				cfg.Client.JWTRoleClaimPath = tt.jwt_role_path
 			}
 			gotUsr, gotRole := extractClaimsFromJWTHeader(tt.args.authorization)
-			suite.Equal(tt.wantUsr, gotUsr, "Unexpected user ID")
-			suite.Equal(tt.wantRole, gotRole, "Unexpected role")
+			assert.Equal(tt.wantUsr, gotUsr, "Unexpected user ID")
+			assert.Equal(tt.wantRole, gotRole, "Unexpected role")
 		})
 	}
 }

docs/CNAME

@@ -1 +0,0 @@
-graphql-monitoring-proxy.raczylo.com

docs/index.html

@@ -1,586 +0,0 @@
-<!doctype html>
-<html lang="en" class="scroll-smooth">
-    <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>GraphQL Monitoring Proxy - High-Performance GraphQL Gateway</title>
-        <meta
-            name="description"
-            content="High-performance GraphQL proxy with monitoring, caching, circuit breaker, rate limiting, and security features. Zero cost monitoring at 30k req/s."
-        />
-        <script src="https://cdn.tailwindcss.com"></script>
-        <script>
-            tailwind.config = {
-                darkMode: 'class'
-            }
-        </script>
-        <link
-            rel="stylesheet"
-            href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.1/css/all.min.css"
-        />
-        <link rel="preconnect" href="https://fonts.googleapis.com" />
-        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
-        <link
-            href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap"
-            rel="stylesheet"
-        />
-        <style>
-            body { font-family: "Inter", sans-serif; }
-            code, pre { font-family: "JetBrains Mono", monospace; }
-            .theme-transition {
-                transition: background-color 0.3s ease, color 0.3s ease, border-color 0.3s ease;
-            }
-            @keyframes fadeInUp {
-                from { opacity: 0; transform: translateY(20px); }
-                to { opacity: 1; transform: translateY(0); }
-            }
-            @keyframes float {
-                0%, 100% { transform: translateY(0px); }
-                50% { transform: translateY(-10px); }
-            }
-            .animate-fade-in-up { animation: fadeInUp 0.6s ease-out; }
-            .animate-float { animation: float 3s ease-in-out infinite; }
-            .glass {
-                background: rgba(255, 255, 255, 0.7);
-                backdrop-filter: blur(10px);
-                -webkit-backdrop-filter: blur(10px);
-                border: 1px solid rgba(255, 255, 255, 0.2);
-            }
-            .dark .glass {
-                background: rgba(17, 24, 39, 0.7);
-                border: 1px solid rgba(255, 255, 255, 0.1);
-            }
-            .gradient-text {
-                background: linear-gradient(135deg, #e879f9 0%, #818cf8 100%);
-                -webkit-background-clip: text;
-                -webkit-text-fill-color: transparent;
-                background-clip: text;
-            }
-            .dark .gradient-text {
-                background: linear-gradient(135deg, #f0abfc 0%, #a5b4fc 100%);
-                -webkit-background-clip: text;
-                -webkit-text-fill-color: transparent;
-                background-clip: text;
-            }
-            .shadow-modern { box-shadow: 0 10px 40px -10px rgba(0, 0, 0, 0.1); }
-            .dark .shadow-modern { box-shadow: 0 10px 40px -10px rgba(0, 0, 0, 0.4); }
-            html { scroll-behavior: smooth; }
-        </style>
-        <script>
-            if (localStorage.theme === "dark" || (!("theme" in localStorage) && window.matchMedia("(prefers-color-scheme: dark)").matches)) {
-                document.documentElement.classList.add("dark");
-            } else {
-                document.documentElement.classList.remove("dark");
-            }
-        </script>
-    </head>
-    <body class="bg-white dark:bg-gray-900 text-gray-900 dark:text-gray-100 theme-transition">
-        <!-- Navigation -->
-        <nav class="fixed w-full glass shadow-modern z-50 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="flex justify-between h-16 items-center">
-                    <a href="#" class="flex items-center hover:opacity-80 transition-opacity duration-300 gap-2">
-                        <i class="fas fa-diagram-project text-2xl gradient-text"></i>
-                        <span class="text-xl font-bold gradient-text">graphql-monitoring-proxy</span>
-                    </a>
-                    <div class="hidden md:flex space-x-6">
-                        <a href="#features" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Features</a>
-                        <a href="#installation" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Installation</a>
-                        <a href="#configuration" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Configuration</a>
-                        <a href="#endpoints" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 font-medium">Endpoints</a>
-                    </div>
-                    <div class="flex items-center space-x-4">
-                        <button id="theme-toggle" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 p-2 min-w-[44px] min-h-[44px] flex items-center justify-center" aria-label="Toggle theme">
-                            <i class="fas fa-moon dark:hidden text-xl"></i>
-                            <i class="fas fa-sun hidden dark:inline text-xl"></i>
-                        </button>
-                        <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy" target="_blank" class="text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 p-2 min-w-[44px] min-h-[44px] flex items-center justify-center" aria-label="View on GitHub">
-                            <i class="fab fa-github text-xl"></i>
-                        </a>
-                        <button id="mobile-menu-toggle" class="md:hidden text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 p-2 min-w-[44px] min-h-[44px] flex items-center justify-center" aria-label="Toggle menu">
-                            <i class="fas fa-bars text-xl" id="menu-open-icon"></i>
-                            <i class="fas fa-times text-xl hidden" id="menu-close-icon"></i>
-                        </button>
-                    </div>
-                </div>
-            </div>
-            <div id="mobile-menu" class="hidden md:hidden border-t border-gray-200 dark:border-gray-700">
-                <div class="px-4 py-3 space-y-1 bg-white dark:bg-gray-800">
-                    <a href="#features" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Features</a>
-                    <a href="#installation" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Installation</a>
-                    <a href="#configuration" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Configuration</a>
-                    <a href="#endpoints" class="block px-3 py-3 text-gray-600 dark:text-gray-300 hover:text-gray-900 dark:hover:text-gray-100 hover:bg-gray-50 dark:hover:bg-gray-700 rounded font-medium">Endpoints</a>
-                </div>
-            </div>
-        </nav>
-
-        <!-- Hero Section -->
-        <section class="relative pt-24 sm:pt-32 pb-12 sm:pb-20 overflow-hidden">
-            <div class="absolute inset-0 bg-gradient-to-br from-fuchsia-50 via-violet-50 to-indigo-50 dark:from-gray-900 dark:via-fuchsia-900/20 dark:to-indigo-900/20 theme-transition"></div>
-            <div class="absolute top-0 -left-4 w-72 h-72 bg-fuchsia-300 dark:bg-fuchsia-500 rounded-full mix-blend-multiply dark:mix-blend-soft-light filter blur-xl opacity-20 animate-float"></div>
-            <div class="absolute top-0 -right-4 w-72 h-72 bg-violet-300 dark:bg-violet-500 rounded-full mix-blend-multiply dark:mix-blend-soft-light filter blur-xl opacity-20 animate-float" style="animation-delay: 1s;"></div>
-            <div class="absolute -bottom-8 left-20 w-72 h-72 bg-indigo-300 dark:bg-indigo-500 rounded-full mix-blend-multiply dark:mix-blend-soft-light filter blur-xl opacity-20 animate-float" style="animation-delay: 2s;"></div>
-
-            <div class="relative max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center">
-                    <div class="mb-8 sm:mb-10 flex justify-center animate-fade-in-up">
-                        <div class="text-8xl sm:text-9xl animate-float">
-                            <i class="fas fa-diagram-project gradient-text"></i>
-                        </div>
-                    </div>
-                    <h1 class="text-3xl sm:text-4xl md:text-5xl lg:text-6xl font-bold text-gray-900 dark:text-gray-100 mb-4 sm:mb-6 leading-tight animate-fade-in-up" style="animation-delay: 0.1s;">
-                        GraphQL Monitoring<br /><span class="gradient-text">Proxy</span>
-                    </h1>
-                    <p class="text-base sm:text-lg md:text-xl text-gray-600 dark:text-gray-300 mb-8 sm:mb-10 max-w-2xl mx-auto leading-relaxed px-4 animate-fade-in-up" style="animation-delay: 0.2s;">
-                        High-performance GraphQL gateway with monitoring, caching, circuit breaker, rate limiting, and security. Tested at 30k req/s using 10MB RAM.
-                    </p>
-                    <div class="flex flex-col sm:flex-row gap-3 sm:gap-4 justify-center mb-8 sm:mb-12 px-4 animate-fade-in-up" style="animation-delay: 0.3s;">
-                        <a href="#installation" class="group relative bg-gradient-to-r from-fuchsia-500 to-indigo-600 hover:from-fuchsia-600 hover:to-indigo-700 text-white px-8 py-3 rounded-lg font-medium transition-all duration-300 min-h-[48px] flex items-center justify-center shadow-lg hover:shadow-xl hover:scale-105">
-                            <span class="relative z-10">Get Started</span>
-                        </a>
-                        <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy" class="group glass hover:shadow-lg text-gray-900 dark:text-gray-100 px-8 py-3 rounded-lg font-medium transition-all duration-300 min-h-[48px] flex items-center justify-center hover:scale-105">
-                            <i class="fab fa-github mr-2"></i>View on GitHub
-                        </a>
-                    </div>
-                    <div class="flex flex-wrap justify-center gap-2 sm:gap-4 text-sm px-4">
-                        <img src="https://img.shields.io/github/v/release/lukaszraczylo/graphql-monitoring-proxy" alt="Version" class="h-5" />
-                        <img src="https://img.shields.io/github/license/lukaszraczylo/graphql-monitoring-proxy" alt="License" class="h-5" />
-                        <img src="https://goreportcard.com/badge/github.com/lukaszraczylo/graphql-monitoring-proxy" alt="Go Report" class="h-5" />
-                    </div>
-                    <div class="mt-12 sm:mt-16 max-w-3xl mx-auto px-4 animate-fade-in-up" style="animation-delay: 0.4s;">
-                        <div class="relative group">
-                            <div class="absolute -inset-1 bg-gradient-to-r from-fuchsia-500 to-indigo-600 rounded-xl blur opacity-25 group-hover:opacity-50 transition duration-500"></div>
-                            <div class="relative bg-gray-900 rounded-xl p-6 text-left">
-                                <div class="flex items-center gap-2 mb-4">
-                                    <div class="w-3 h-3 rounded-full bg-red-500"></div>
-                                    <div class="w-3 h-3 rounded-full bg-yellow-500"></div>
-                                    <div class="w-3 h-3 rounded-full bg-green-500"></div>
-                                    <span class="ml-2 text-gray-400 text-sm">terminal</span>
-                                </div>
-                                <pre class="text-gray-100 text-sm sm:text-base overflow-x-auto"><code><span class="text-gray-400"># Run with Docker</span>
-<span class="text-fuchsia-400">$</span> docker pull ghcr.io/lukaszraczylo/graphql-monitoring-proxy:latest
-
-<span class="text-gray-400"># Configure and run</span>
-<span class="text-fuchsia-400">$</span> docker run -p 8080:8080 -p 9393:9393 \
-    -e GMP_HOST_GRAPHQL=http://your-graphql:4000/ \
-    ghcr.io/lukaszraczylo/graphql-monitoring-proxy:latest</code></pre>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Features Section -->
-        <section id="features" class="py-12 sm:py-16 md:py-20 bg-white dark:bg-gray-900 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Features</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Enterprise-grade GraphQL gateway at zero cost</p>
-                </div>
-                <div class="grid sm:grid-cols-2 lg:grid-cols-3 gap-4">
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-fuchsia-500 to-fuchsia-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-chart-line text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Prometheus Metrics</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Full observability with query timing, user tracking, and operation metrics</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-violet-500 to-violet-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-bolt text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Smart Caching</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Memory-aware caching with LRU eviction, compression, and Redis support</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-indigo-500 to-indigo-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-shield-halved text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Circuit Breaker</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Automatic failure detection with graceful degradation and cached fallbacks</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-rose-500 to-rose-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-gauge-high text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Rate Limiting</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Role-based rate limiting with JWT extraction and burst control</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-amber-500 to-amber-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-layer-group text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Request Coalescing</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Deduplicate concurrent identical queries, reducing backend load 50-80%</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-emerald-500 to-emerald-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-plug text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">WebSocket Support</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Native GraphQL subscriptions with bidirectional proxying</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-cyan-500 to-cyan-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-eye-slash text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Introspection Blocking</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Block schema introspection with configurable allowlists</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-orange-500 to-orange-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-satellite-dish text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">OpenTelemetry Tracing</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Distributed tracing with configurable OTLP collector endpoint</p>
-                            </div>
-                        </div>
-                    </div>
-                    <div class="glass p-5 rounded-xl group hover:shadow-lg transition-all duration-300">
-                        <div class="flex items-start gap-4">
-                            <div class="w-12 h-12 rounded-xl bg-gradient-to-br from-pink-500 to-pink-600 flex items-center justify-center flex-shrink-0 group-hover:scale-110 transition-transform duration-300">
-                                <i class="fas fa-desktop text-white"></i>
-                            </div>
-                            <div>
-                                <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-1">Admin Dashboard</h3>
-                                <p class="text-sm text-gray-600 dark:text-gray-400">Real-time web UI for monitoring health, metrics, and controls</p>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Installation Section -->
-        <section id="installation" class="py-12 sm:py-16 md:py-20 bg-gray-50 dark:bg-gray-800 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Installation</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Deploy in seconds</p>
-                </div>
-                <div class="max-w-3xl mx-auto space-y-6">
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-3 flex items-center">
-                            <i class="fab fa-docker mr-2 text-blue-500"></i>
-                            Docker
-                        </h3>
-                        <pre class="bg-gray-900 text-gray-100 p-4 rounded-lg overflow-x-auto"><code>docker pull ghcr.io/lukaszraczylo/graphql-monitoring-proxy:latest</code></pre>
-                    </div>
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-3 flex items-center">
-                            <i class="fas fa-download mr-2 text-fuchsia-500"></i>
-                            Binary Download
-                        </h3>
-                        <p class="text-gray-600 dark:text-gray-400 mb-3">Download from the <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy/releases/latest" class="text-fuchsia-600 dark:text-fuchsia-400 hover:underline">releases page</a>.</p>
-                        <p class="text-sm text-gray-500 dark:text-gray-400">Supported: Darwin ARM64/AMD64, Linux ARM64/AMD64, Windows AMD64</p>
-                    </div>
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-3 flex items-center">
-                            <i class="fas fa-dharmachakra mr-2 text-indigo-500"></i>
-                            Kubernetes
-                        </h3>
-                        <p class="text-gray-600 dark:text-gray-400 mb-3">Example manifests available in the repository:</p>
-                        <ul class="text-sm text-gray-500 dark:text-gray-400 space-y-1">
-                            <li><a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy/blob/main/static/kubernetes-deployment.yaml" class="text-fuchsia-600 dark:text-fuchsia-400 hover:underline">Standalone deployment</a></li>
-                            <li><a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy/blob/main/static/kubernetes-single-deployment.yaml" class="text-fuchsia-600 dark:text-fuchsia-400 hover:underline">Combined deployment</a></li>
-                            <li><a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy/blob/main/static/kubernetes-single-deployment-with-ro.yaml" class="text-fuchsia-600 dark:text-fuchsia-400 hover:underline">Combined with read-only replica</a></li>
-                        </ul>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Endpoints Section -->
-        <section id="endpoints" class="py-12 sm:py-16 md:py-20 bg-white dark:bg-gray-900 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Endpoints</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Available HTTP endpoints</p>
-                </div>
-                <div class="max-w-3xl mx-auto">
-                    <div class="glass p-6 rounded-xl">
-                        <div class="space-y-4">
-                            <div class="flex items-start gap-4 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                <code class="text-fuchsia-600 dark:text-fuchsia-400 font-medium whitespace-nowrap">:8080/*</code>
-                                <span class="text-gray-600 dark:text-gray-400">GraphQL passthrough endpoint</span>
-                            </div>
-                            <div class="flex items-start gap-4 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                <code class="text-fuchsia-600 dark:text-fuchsia-400 font-medium whitespace-nowrap">:8080/admin</code>
-                                <span class="text-gray-600 dark:text-gray-400">Admin dashboard UI</span>
-                            </div>
-                            <div class="flex items-start gap-4 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                <code class="text-fuchsia-600 dark:text-fuchsia-400 font-medium whitespace-nowrap">:9393/metrics</code>
-                                <span class="text-gray-600 dark:text-gray-400">Prometheus metrics endpoint</span>
-                            </div>
-                            <div class="flex items-start gap-4 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                <code class="text-fuchsia-600 dark:text-fuchsia-400 font-medium whitespace-nowrap">:8080/healthz</code>
-                                <span class="text-gray-600 dark:text-gray-400">Health check endpoint</span>
-                            </div>
-                            <div class="flex items-start gap-4 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                <code class="text-fuchsia-600 dark:text-fuchsia-400 font-medium whitespace-nowrap">:8080/livez</code>
-                                <span class="text-gray-600 dark:text-gray-400">Liveness probe endpoint</span>
-                            </div>
-                            <div class="flex items-start gap-4 p-3 bg-gray-50 dark:bg-gray-800 rounded-lg">
-                                <code class="text-fuchsia-600 dark:text-fuchsia-400 font-medium whitespace-nowrap">:9090/api/*</code>
-                                <span class="text-gray-600 dark:text-gray-400">Management API (ban/unban, cache, circuit breaker)</span>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Configuration Section -->
-        <section id="configuration" class="py-12 sm:py-16 md:py-20 bg-gray-50 dark:bg-gray-800 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Configuration</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Environment variables (prefix with GMP_ recommended)</p>
-                </div>
-                <div class="max-w-4xl mx-auto space-y-6">
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-4 flex items-center">
-                            <i class="fas fa-server mr-2 text-fuchsia-500"></i>
-                            Core Settings
-                        </h3>
-                        <div class="overflow-x-auto">
-                            <table class="w-full text-sm">
-                                <thead>
-                                    <tr class="text-left text-gray-500 dark:text-gray-400 border-b border-gray-200 dark:border-gray-700">
-                                        <th class="pb-2 pr-4">Variable</th>
-                                        <th class="pb-2 pr-4">Description</th>
-                                        <th class="pb-2">Default</th>
-                                    </tr>
-                                </thead>
-                                <tbody class="text-gray-600 dark:text-gray-300">
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">HOST_GRAPHQL</code></td>
-                                        <td class="py-2 pr-4">GraphQL backend URL</td>
-                                        <td class="py-2">http://localhost/</td>
-                                    </tr>
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">PORT_GRAPHQL</code></td>
-                                        <td class="py-2 pr-4">Proxy listen port</td>
-                                        <td class="py-2">8080</td>
-                                    </tr>
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">MONITORING_PORT</code></td>
-                                        <td class="py-2 pr-4">Metrics endpoint port</td>
-                                        <td class="py-2">9393</td>
-                                    </tr>
-                                    <tr>
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">LOG_LEVEL</code></td>
-                                        <td class="py-2 pr-4">Logging level</td>
-                                        <td class="py-2">info</td>
-                                    </tr>
-                                </tbody>
-                            </table>
-                        </div>
-                    </div>
-
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-4 flex items-center">
-                            <i class="fas fa-bolt mr-2 text-violet-500"></i>
-                            Caching
-                        </h3>
-                        <div class="overflow-x-auto">
-                            <table class="w-full text-sm">
-                                <thead>
-                                    <tr class="text-left text-gray-500 dark:text-gray-400 border-b border-gray-200 dark:border-gray-700">
-                                        <th class="pb-2 pr-4">Variable</th>
-                                        <th class="pb-2 pr-4">Description</th>
-                                        <th class="pb-2">Default</th>
-                                    </tr>
-                                </thead>
-                                <tbody class="text-gray-600 dark:text-gray-300">
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">ENABLE_GLOBAL_CACHE</code></td>
-                                        <td class="py-2 pr-4">Enable memory cache</td>
-                                        <td class="py-2">false</td>
-                                    </tr>
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">CACHE_TTL</code></td>
-                                        <td class="py-2 pr-4">Cache TTL in seconds</td>
-                                        <td class="py-2">60</td>
-                                    </tr>
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">CACHE_MAX_MEMORY_SIZE</code></td>
-                                        <td class="py-2 pr-4">Max memory in MB</td>
-                                        <td class="py-2">100</td>
-                                    </tr>
-                                    <tr>
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">ENABLE_REDIS_CACHE</code></td>
-                                        <td class="py-2 pr-4">Enable Redis cache</td>
-                                        <td class="py-2">false</td>
-                                    </tr>
-                                </tbody>
-                            </table>
-                        </div>
-                    </div>
-
-                    <div class="glass p-6 rounded-xl">
-                        <h3 class="font-semibold text-gray-900 dark:text-gray-100 mb-4 flex items-center">
-                            <i class="fas fa-shield-halved mr-2 text-indigo-500"></i>
-                            Circuit Breaker
-                        </h3>
-                        <div class="overflow-x-auto">
-                            <table class="w-full text-sm">
-                                <thead>
-                                    <tr class="text-left text-gray-500 dark:text-gray-400 border-b border-gray-200 dark:border-gray-700">
-                                        <th class="pb-2 pr-4">Variable</th>
-                                        <th class="pb-2 pr-4">Description</th>
-                                        <th class="pb-2">Default</th>
-                                    </tr>
-                                </thead>
-                                <tbody class="text-gray-600 dark:text-gray-300">
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">ENABLE_CIRCUIT_BREAKER</code></td>
-                                        <td class="py-2 pr-4">Enable circuit breaker</td>
-                                        <td class="py-2">false</td>
-                                    </tr>
-                                    <tr class="border-b border-gray-100 dark:border-gray-700">
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">CIRCUIT_MAX_FAILURES</code></td>
-                                        <td class="py-2 pr-4">Failures before trip</td>
-                                        <td class="py-2">10</td>
-                                    </tr>
-                                    <tr>
-                                        <td class="py-2 pr-4"><code class="text-fuchsia-600 dark:text-fuchsia-400">CIRCUIT_TIMEOUT_SECONDS</code></td>
-                                        <td class="py-2 pr-4">Recovery timeout</td>
-                                        <td class="py-2">60</td>
-                                    </tr>
-                                </tbody>
-                            </table>
-                        </div>
-                    </div>
-
-                    <div class="text-center mt-8">
-                        <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy#configuration" class="inline-flex items-center text-fuchsia-600 dark:text-fuchsia-400 hover:underline font-medium">
-                            View all configuration options
-                            <i class="fas fa-arrow-right ml-2"></i>
-                        </a>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Performance Section -->
-        <section class="py-12 sm:py-16 md:py-20 bg-white dark:bg-gray-900 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="text-center mb-8 sm:mb-12">
-                    <h2 class="text-2xl sm:text-3xl md:text-4xl font-bold text-gray-900 dark:text-gray-100 mb-3 sm:mb-4">Performance</h2>
-                    <p class="text-base sm:text-lg text-gray-600 dark:text-gray-300 px-4">Battle-tested at scale</p>
-                </div>
-                <div class="max-w-3xl mx-auto">
-                    <div class="grid sm:grid-cols-3 gap-4 text-center">
-                        <div class="glass p-6 rounded-xl">
-                            <div class="text-4xl font-bold gradient-text mb-2">100k+</div>
-                            <p class="text-sm text-gray-600 dark:text-gray-400">Requests/second</p>
-                        </div>
-                        <div class="glass p-6 rounded-xl">
-                            <div class="text-4xl font-bold gradient-text mb-2">10MB</div>
-                            <p class="text-sm text-gray-600 dark:text-gray-400">RAM usage</p>
-                        </div>
-                        <div class="glass p-6 rounded-xl">
-                            <div class="text-4xl font-bold gradient-text mb-2">0.1%</div>
-                            <p class="text-sm text-gray-600 dark:text-gray-400">CPU usage</p>
-                        </div>
-                    </div>
-                    <div class="mt-8 text-center">
-                        <a href="bench/" class="inline-flex items-center text-fuchsia-600 dark:text-fuchsia-400 hover:underline font-medium">
-                            View benchmarks
-                            <i class="fas fa-arrow-right ml-2"></i>
-                        </a>
-                    </div>
-                </div>
-            </div>
-        </section>
-
-        <!-- Footer -->
-        <footer class="py-8 bg-gray-100 dark:bg-gray-800 theme-transition">
-            <div class="max-w-6xl mx-auto px-4 sm:px-6">
-                <div class="flex flex-col sm:flex-row justify-between items-center gap-4">
-                    <div class="flex items-center gap-2">
-                        <i class="fas fa-diagram-project text-xl gradient-text"></i>
-                        <span class="font-semibold gradient-text">graphql-monitoring-proxy</span>
-                    </div>
-                    <div class="flex items-center gap-6">
-                        <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy" class="text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100">
-                            <i class="fab fa-github text-xl"></i>
-                        </a>
-                        <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy/issues" class="text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100 text-sm">
-                            Issues
-                        </a>
-                        <a href="https://github.com/lukaszraczylo/graphql-monitoring-proxy/releases" class="text-gray-600 dark:text-gray-400 hover:text-gray-900 dark:hover:text-gray-100 text-sm">
-                            Releases
-                        </a>
-                    </div>
-                    <p class="text-gray-500 dark:text-gray-400 text-sm">MIT License</p>
-                </div>
-            </div>
-        </footer>
-
-        <script>
-            // Theme toggle
-            document.getElementById('theme-toggle').addEventListener('click', function() {
-                if (document.documentElement.classList.contains('dark')) {
-                    document.documentElement.classList.remove('dark');
-                    localStorage.theme = 'light';
-                } else {
-                    document.documentElement.classList.add('dark');
-                    localStorage.theme = 'dark';
-                }
-            });
-
-            // Mobile menu toggle
-            document.getElementById('mobile-menu-toggle').addEventListener('click', function() {
-                const menu = document.getElementById('mobile-menu');
-                const openIcon = document.getElementById('menu-open-icon');
-                const closeIcon = document.getElementById('menu-close-icon');
-
-                menu.classList.toggle('hidden');
-                openIcon.classList.toggle('hidden');
-                closeIcon.classList.toggle('hidden');
-            });
-
-            // Close mobile menu when clicking a link
-            document.querySelectorAll('#mobile-menu a').forEach(link => {
-                link.addEventListener('click', () => {
-                    document.getElementById('mobile-menu').classList.add('hidden');
-                    document.getElementById('menu-open-icon').classList.remove('hidden');
-                    document.getElementById('menu-close-icon').classList.add('hidden');
-                });
-            });
-        </script>
-    </body>
-</html>

errors.go

@@ -1,142 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"time"
-)
-
-// Error codes for structured error responses
-const (
-	ErrCodeConnectionRefused  = "CONNECTION_REFUSED"
-	ErrCodeConnectionReset    = "CONNECTION_RESET"
-	ErrCodeTimeout            = "TIMEOUT"
-	ErrCodeCircuitOpen        = "CIRCUIT_OPEN"
-	ErrCodeRateLimited        = "RATE_LIMITED"
-	ErrCodeInvalidRequest     = "INVALID_REQUEST"
-	ErrCodeBackendError       = "BACKEND_ERROR"
-	ErrCodeInternalError      = "INTERNAL_ERROR"
-	ErrCodeUnauthorized       = "UNAUTHORIZED"
-	ErrCodeForbidden          = "FORBIDDEN"
-	ErrCodeNotFound           = "NOT_FOUND"
-	ErrCodeServiceUnavailable = "SERVICE_UNAVAILABLE"
-	ErrCodeBadGateway         = "BAD_GATEWAY"
-	ErrCodeInvalidResponse    = "INVALID_RESPONSE"
-	ErrCodeQueryTooComplex    = "QUERY_TOO_COMPLEX"
-	ErrCodeCacheFailed        = "CACHE_FAILED"
-	ErrCodeContextCanceled    = "CONTEXT_CANCELED"
-)
-
-// ProxyError represents a structured error response
-type ProxyError struct {
-	Code       string                 `json:"code"`               // Machine-readable error code
-	Message    string                 `json:"message"`            // Human-readable error message
-	Details    string                 `json:"details,omitempty"`  // Additional error details
-	Retryable  bool                   `json:"retryable"`          // Whether the request can be retried
-	StatusCode int                    `json:"status_code"`        // HTTP status code
-	Timestamp  time.Time              `json:"timestamp"`          // When the error occurred
-	TraceID    string                 `json:"trace_id,omitempty"` // Trace ID for correlation
-	Metadata   map[string]interface{} `json:"metadata,omitempty"` // Additional context
-	Cause      error                  `json:"-"`                  // Original error (not serialized)
-}
-
-// Error implements the error interface
-func (e *ProxyError) Error() string {
-	if e.Details != "" {
-		return fmt.Sprintf("%s: %s (%s)", e.Code, e.Message, e.Details)
-	}
-	return fmt.Sprintf("%s: %s", e.Code, e.Message)
-}
-
-// Unwrap returns the underlying error
-func (e *ProxyError) Unwrap() error {
-	return e.Cause
-}
-
-// MarshalJSON implements custom JSON marshaling
-func (e *ProxyError) MarshalJSON() ([]byte, error) {
-	type Alias ProxyError
-	return json.Marshal(&struct {
-		*Alias
-		CauseMessage string `json:"cause,omitempty"`
-	}{
-		Alias: (*Alias)(e),
-		CauseMessage: func() string {
-			if e.Cause != nil {
-				return e.Cause.Error()
-			}
-			return ""
-		}(),
-	})
-}
-
-// NewProxyError creates a new structured error
-func NewProxyError(code, message string, statusCode int, retryable bool) *ProxyError {
-	return &ProxyError{
-		Code:       code,
-		Message:    message,
-		StatusCode: statusCode,
-		Retryable:  retryable,
-		Timestamp:  time.Now(),
-		Metadata:   make(map[string]interface{}),
-	}
-}
-
-// WithDetails adds details to the error
-func (e *ProxyError) WithDetails(details string) *ProxyError {
-	e.Details = details
-	return e
-}
-
-// WithCause adds the underlying cause
-func (e *ProxyError) WithCause(cause error) *ProxyError {
-	e.Cause = cause
-	return e
-}
-
-// WithTraceID adds a trace ID
-func (e *ProxyError) WithTraceID(traceID string) *ProxyError {
-	e.TraceID = traceID
-	return e
-}
-
-// WithMetadata adds metadata
-func (e *ProxyError) WithMetadata(key string, value interface{}) *ProxyError {
-	e.Metadata[key] = value
-	return e
-}
-
-// Helper functions
-
-func truncateString(s string, maxLen int) string {
-	if len(s) <= maxLen {
-		return s
-	}
-	return s[:maxLen] + "..."
-}
-
-// IsRetryable checks if an error is retryable
-func IsRetryable(err error) bool {
-	if err == nil {
-		return false
-	}
-
-	if proxyErr, ok := err.(*ProxyError); ok {
-		return proxyErr.Retryable
-	}
-
-	return false
-}
-
-// GetStatusCode extracts the status code from an error
-func GetStatusCode(err error) int {
-	if err == nil {
-		return 200
-	}
-
-	if proxyErr, ok := err.(*ProxyError); ok {
-		return proxyErr.StatusCode
-	}
-
-	return 500
-}

errors_test.go

@@ -1,243 +0,0 @@
-package main
-
-import (
-	"errors"
-	"net/http"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewProxyError(t *testing.T) {
-	tests := []struct {
-		name         string
-		code         string
-		message      string
-		statusCode   int
-		retryable    bool
-		expectStatus int
-	}{
-		{
-			name:         "connection refused error",
-			code:         ErrCodeConnectionRefused,
-			message:      "backend unavailable",
-			statusCode:   http.StatusServiceUnavailable,
-			retryable:    true,
-			expectStatus: http.StatusServiceUnavailable,
-		},
-		{
-			name:         "timeout error",
-			code:         ErrCodeTimeout,
-			message:      "request timeout",
-			statusCode:   http.StatusGatewayTimeout,
-			retryable:    true,
-			expectStatus: http.StatusGatewayTimeout,
-		},
-		{
-			name:         "circuit breaker open",
-			code:         ErrCodeCircuitOpen,
-			message:      "circuit breaker open",
-			statusCode:   http.StatusServiceUnavailable,
-			retryable:    false,
-			expectStatus: http.StatusServiceUnavailable,
-		},
-		{
-			name:         "rate limit exceeded",
-			code:         ErrCodeRateLimited,
-			message:      "too many requests",
-			statusCode:   http.StatusTooManyRequests,
-			retryable:    false,
-			expectStatus: http.StatusTooManyRequests,
-		},
-		{
-			name:         "service unavailable",
-			code:         ErrCodeServiceUnavailable,
-			message:      "no retry tokens available",
-			statusCode:   http.StatusServiceUnavailable,
-			retryable:    false,
-			expectStatus: http.StatusServiceUnavailable,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := NewProxyError(tt.code, tt.message, tt.statusCode, tt.retryable)
-
-			assert.NotNil(t, err)
-			assert.Equal(t, tt.code, err.Code)
-			assert.Equal(t, tt.message, err.Message)
-			assert.Equal(t, tt.retryable, err.Retryable)
-			assert.Equal(t, tt.expectStatus, err.StatusCode)
-			assert.NotEmpty(t, err.Timestamp)
-			assert.NotNil(t, err.Metadata)
-		})
-	}
-}
-
-func TestProxyError_Error(t *testing.T) {
-	tests := []struct {
-		name     string
-		err      *ProxyError
-		expected string
-	}{
-		{
-			name: "error with details",
-			err: NewProxyError(ErrCodeConnectionRefused, "backend unavailable", http.StatusServiceUnavailable, true).
-				WithDetails("connection refused"),
-			expected: "CONNECTION_REFUSED: backend unavailable (connection refused)",
-		},
-		{
-			name:     "error without details",
-			err:      NewProxyError(ErrCodeCircuitOpen, "circuit breaker open", http.StatusServiceUnavailable, false),
-			expected: "CIRCUIT_OPEN: circuit breaker open",
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			assert.Equal(t, tt.expected, tt.err.Error())
-		})
-	}
-}
-
-func TestProxyError_Unwrap(t *testing.T) {
-	cause := errors.New("original error")
-	err := NewProxyError(ErrCodeTimeout, "timeout occurred", http.StatusGatewayTimeout, true).WithCause(cause)
-
-	unwrapped := errors.Unwrap(err)
-	assert.Equal(t, cause, unwrapped)
-}
-
-func TestProxyError_WithMethods(t *testing.T) {
-	t.Run("with details", func(t *testing.T) {
-		err := NewProxyError(ErrCodeTimeout, "timeout", http.StatusGatewayTimeout, true).
-			WithDetails("operation timed out")
-
-		assert.Equal(t, "operation timed out", err.Details)
-	})
-
-	t.Run("with cause", func(t *testing.T) {
-		cause := errors.New("original error")
-		err := NewProxyError(ErrCodeTimeout, "timeout", http.StatusGatewayTimeout, true).
-			WithCause(cause)
-
-		assert.Equal(t, cause, err.Cause)
-	})
-
-	t.Run("with trace ID", func(t *testing.T) {
-		err := NewProxyError(ErrCodeTimeout, "timeout", http.StatusGatewayTimeout, true).
-			WithTraceID("trace-123")
-
-		assert.Equal(t, "trace-123", err.TraceID)
-	})
-
-	t.Run("with metadata", func(t *testing.T) {
-		err := NewProxyError(ErrCodeTimeout, "timeout", http.StatusGatewayTimeout, true).
-			WithMetadata("attempt", 3).
-			WithMetadata("endpoint", "/graphql")
-
-		assert.Equal(t, 3, err.Metadata["attempt"])
-		assert.Equal(t, "/graphql", err.Metadata["endpoint"])
-	})
-}
-
-func TestProxyError_MarshalJSON(t *testing.T) {
-	cause := errors.New("connection refused")
-	err := NewProxyError(ErrCodeConnectionRefused, "backend unavailable", http.StatusServiceUnavailable, true).
-		WithDetails("network error").
-		WithCause(cause).
-		WithTraceID("trace-456")
-
-	data, jsonErr := err.MarshalJSON()
-	assert.NoError(t, jsonErr)
-	assert.NotEmpty(t, data)
-	assert.Contains(t, string(data), "CONNECTION_REFUSED")
-	assert.Contains(t, string(data), "backend unavailable")
-	assert.Contains(t, string(data), "connection refused")
-}
-
-func TestErrorCodes(t *testing.T) {
-	// Verify all error codes are defined
-	codes := []string{
-		ErrCodeConnectionRefused,
-		ErrCodeConnectionReset,
-		ErrCodeTimeout,
-		ErrCodeCircuitOpen,
-		ErrCodeRateLimited,
-		ErrCodeInvalidRequest,
-		ErrCodeBackendError,
-		ErrCodeInternalError,
-		ErrCodeUnauthorized,
-		ErrCodeForbidden,
-		ErrCodeNotFound,
-		ErrCodeServiceUnavailable,
-		ErrCodeBadGateway,
-		ErrCodeInvalidResponse,
-		ErrCodeQueryTooComplex,
-		ErrCodeCacheFailed,
-		ErrCodeContextCanceled,
-	}
-
-	for _, code := range codes {
-		assert.NotEmpty(t, code, "Error code should not be empty")
-	}
-
-	// Verify codes are unique
-	codeMap := make(map[string]bool)
-	for _, code := range codes {
-		assert.False(t, codeMap[code], "Error code %s should be unique", code)
-		codeMap[code] = true
-	}
-}
-
-func TestProxyError_ChainableMethods(t *testing.T) {
-	// Test that methods can be chained
-	err := NewProxyError(ErrCodeTimeout, "timeout", http.StatusGatewayTimeout, true).
-		WithDetails("operation timeout").
-		WithCause(errors.New("deadline exceeded")).
-		WithTraceID("trace-789").
-		WithMetadata("attempt", 1).
-		WithMetadata("duration_ms", 5000)
-
-	assert.Equal(t, "operation timeout", err.Details)
-	assert.NotNil(t, err.Cause)
-	assert.Equal(t, "trace-789", err.TraceID)
-	assert.Equal(t, 1, err.Metadata["attempt"])
-	assert.Equal(t, 5000, err.Metadata["duration_ms"])
-}
-
-func TestProxyError_Retryable(t *testing.T) {
-	tests := []struct {
-		name      string
-		code      string
-		retryable bool
-	}{
-		{
-			name:      "timeout is retryable",
-			code:      ErrCodeTimeout,
-			retryable: true,
-		},
-		{
-			name:      "connection refused is retryable",
-			code:      ErrCodeConnectionRefused,
-			retryable: true,
-		},
-		{
-			name:      "rate limited is not retryable",
-			code:      ErrCodeRateLimited,
-			retryable: false,
-		},
-		{
-			name:      "circuit open is not retryable",
-			code:      ErrCodeCircuitOpen,
-			retryable: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			err := NewProxyError(tt.code, "test error", http.StatusInternalServerError, tt.retryable)
-			assert.Equal(t, tt.retryable, err.Retryable)
-		})
-	}
-}

events.go

@@ -14,118 +14,75 @@ const (
 	cleanupInterval = 1 * time.Hour
 )
 
-// Use parameterized queries to prevent SQL injection
-// Cast $1 to interval type to allow proper parameterized interval values
 var delQueries = [...]string{
-	"DELETE FROM hdb_catalog.event_invocation_logs WHERE created_at < NOW() - $1::INTERVAL",
-	"DELETE FROM hdb_catalog.event_log WHERE created_at < NOW() - $1::INTERVAL",
-	"DELETE FROM hdb_catalog.hdb_action_log WHERE created_at < NOW() - $1::INTERVAL",
-	"DELETE FROM hdb_catalog.hdb_cron_event_invocation_logs WHERE created_at < NOW() - $1::INTERVAL",
-	"DELETE FROM hdb_catalog.hdb_scheduled_event_invocation_logs WHERE created_at < NOW() - $1::INTERVAL",
+	"DELETE FROM hdb_catalog.event_invocation_logs WHERE created_at < NOW() - interval '%d days';",
+	"DELETE FROM hdb_catalog.event_log WHERE created_at < NOW() - interval '%d days';",
+	"DELETE FROM hdb_catalog.hdb_action_log WHERE created_at < NOW() - INTERVAL '%d days';",
+	"DELETE FROM hdb_catalog.hdb_cron_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';",
+	"DELETE FROM hdb_catalog.hdb_scheduled_event_invocation_logs WHERE created_at < NOW() - INTERVAL '%d days';",
 }
 
-func enableHasuraEventCleaner(ctx context.Context) error {
-	cfgMutex.RLock()
+func enableHasuraEventCleaner() {
 	if !cfg.HasuraEventCleaner.Enable {
-		cfgMutex.RUnlock()
-		return nil
+		return
 	}
 
-	eventMetadataDb := cfg.HasuraEventCleaner.EventMetadataDb
-	if eventMetadataDb == "" {
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-
-		logger.Warning(&libpack_logger.LogMessage{
+	if cfg.HasuraEventCleaner.EventMetadataDb == "" {
+		cfg.Logger.Warning(&libpack_logger.LogMessage{
 			Message: "Event metadata db URL not specified, event cleaner not active",
 		})
-		return nil
+		return
 	}
 
-	clearOlderThan := cfg.HasuraEventCleaner.ClearOlderThan
-	logger := cfg.Logger
-	cfgMutex.RUnlock()
-
-	logger.Info(&libpack_logger.LogMessage{
+	cfg.Logger.Info(&libpack_logger.LogMessage{
 		Message: "Event cleaner enabled",
-		Pairs:   map[string]interface{}{"interval_in_days": clearOlderThan},
+		Pairs:   map[string]interface{}{"interval_in_days": cfg.HasuraEventCleaner.ClearOlderThan},
 	})
 
-	// Parse pool configuration
-	poolConfig, err := pgxpool.ParseConfig(eventMetadataDb)
-	if err != nil {
-		return err
-	}
-
-	// Set connection pool limits
-	poolConfig.MaxConns = 10
-	poolConfig.MinConns = 2
-	poolConfig.MaxConnLifetime = time.Hour
-	poolConfig.MaxConnIdleTime = 30 * time.Minute
-
-	pool, err := pgxpool.NewWithConfig(ctx, poolConfig)
-	if err != nil {
-		logger.Error(&libpack_logger.LogMessage{
-			Message: "Failed to create connection pool",
-			Pairs:   map[string]interface{}{"error": err.Error()},
-		})
-		return err
-	}
-
 	go func() {
+		pool, err := pgxpool.New(context.Background(), cfg.HasuraEventCleaner.EventMetadataDb)
+		if err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Failed to create connection pool",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			return
+		}
 		defer pool.Close()
 
-		// Wait for initial delay or context cancellation
-		select {
-		case <-ctx.Done():
-			return
-		case <-time.After(initialDelay):
-		}
+		time.Sleep(initialDelay)
 
-		logger.Info(&libpack_logger.LogMessage{
+		cfg.Logger.Info(&libpack_logger.LogMessage{
 			Message: "Initial cleanup of old events",
 		})
-		cleanEvents(ctx, pool, clearOlderThan, logger)
+		cleanEvents(pool)
 
 		ticker := time.NewTicker(cleanupInterval)
 		defer ticker.Stop()
 
-		for {
-			select {
-			case <-ctx.Done():
-				logger.Info(&libpack_logger.LogMessage{
-					Message: "Stopping event cleaner",
-				})
-				return
-			case <-ticker.C:
-				logger.Info(&libpack_logger.LogMessage{
-					Message: "Cleaning up old events",
-				})
-				cleanEvents(ctx, pool, clearOlderThan, logger)
-			}
+		for range ticker.C {
+			cfg.Logger.Info(&libpack_logger.LogMessage{
+				Message: "Cleaning up old events",
+			})
+			cleanEvents(pool)
 		}
 	}()
-
-	return nil
 }
 
-func cleanEvents(ctx context.Context, pool *pgxpool.Pool, clearOlderThan int, logger *libpack_logger.Logger) {
+func cleanEvents(pool *pgxpool.Pool) {
+	ctx := context.Background()
 	var errors []error
 	var failedQueries []string
 
-	// Format interval parameter for PostgreSQL
-	interval := fmt.Sprintf("%d days", clearOlderThan)
-
 	for _, query := range delQueries {
-		// Use parameterized query with bound parameter to prevent SQL injection
-		_, err := pool.Exec(ctx, query, interval)
+		_, err := pool.Exec(ctx, fmt.Sprintf(query, cfg.HasuraEventCleaner.ClearOlderThan))
 		if err != nil {
 			errors = append(errors, err)
 			failedQueries = append(failedQueries, query)
 		} else {
-			logger.Debug(&libpack_logger.LogMessage{
+			cfg.Logger.Debug(&libpack_logger.LogMessage{
 				Message: "Successfully executed query",
-				Pairs:   map[string]interface{}{"query": query, "interval": interval},
+				Pairs:   map[string]interface{}{"query": query},
 			})
 		}
 	}
@@ -135,7 +92,7 @@ func cleanEvents(ctx context.Context, pool *pgxpool.Pool, clearOlderThan int, lo
 		for _, err := range errors {
 			errMsgs = append(errMsgs, err.Error())
 		}
-		logger.Error(&libpack_logger.LogMessage{
+		cfg.Logger.Error(&libpack_logger.LogMessage{
 			Message: "Failed to execute some queries",
 			Pairs: map[string]interface{}{
 				"failed_queries": failedQueries,

events_security_test.go

@@ -1,355 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"testing"
-	"time"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/suite"
-)
-
-type EventsSecurityTestSuite struct {
-	suite.Suite
-	logger *libpack_logging.Logger
-}
-
-func (suite *EventsSecurityTestSuite) SetupTest() {
-	suite.logger = libpack_logging.New()
-}
-
-func TestEventsSecurityTestSuite(t *testing.T) {
-	suite.Run(t, new(EventsSecurityTestSuite))
-}
-
-// TestEventCleanerSQLInjection tests various SQL injection attempts in the event cleaner
-func (suite *EventsSecurityTestSuite) TestEventCleanerSQLInjection() {
-	tests := []struct {
-		clearDays   interface{}
-		name        string
-		description string
-		expectError bool
-	}{
-		{
-			name:        "SQL injection attempt with OR clause",
-			clearDays:   "1' OR '1'='1",
-			expectError: true,
-			description: "Should reject string input that attempts SQL injection",
-		},
-		{
-			name:        "SQL injection with DROP TABLE",
-			clearDays:   "1'; DROP TABLE users; --",
-			expectError: true,
-			description: "Should reject attempt to drop tables",
-		},
-		{
-			name:        "SQL injection with UNION SELECT",
-			clearDays:   "1 UNION SELECT * FROM information_schema.tables",
-			expectError: true,
-			description: "Should reject UNION-based injection attempts",
-		},
-		{
-			name:        "SQL injection with comment bypass",
-			clearDays:   "1/**/OR/**/1=1",
-			expectError: true,
-			description: "Should reject comment-based bypass attempts",
-		},
-		{
-			name:        "SQL injection with nested quotes",
-			clearDays:   "1' AND '1'='1' OR '2'='2",
-			expectError: true,
-			description: "Should reject nested quote injection attempts",
-		},
-		{
-			name:        "Valid integer input",
-			clearDays:   30,
-			expectError: false,
-			description: "Should accept valid positive integer",
-		},
-		{
-			name:        "Valid integer as string",
-			clearDays:   "30",
-			expectError: false,
-			description: "Should accept valid integer as string",
-		},
-		{
-			name:        "Zero value",
-			clearDays:   0,
-			expectError: false,
-			description: "Should accept zero value",
-		},
-		{
-			name:        "Negative value attempt",
-			clearDays:   -1,
-			expectError: true,
-			description: "Should reject negative values",
-		},
-		{
-			name:        "Float value attempt",
-			clearDays:   3.14,
-			expectError: true,
-			description: "Should reject float values",
-		},
-		{
-			name:        "Very large integer",
-			clearDays:   999999999,
-			expectError: true,
-			description: "Should reject unreasonably large values",
-		},
-		{
-			name:        "Boolean value attempt",
-			clearDays:   true,
-			expectError: true,
-			description: "Should reject boolean values",
-		},
-		{
-			name:        "Null/nil value attempt",
-			clearDays:   nil,
-			expectError: true,
-			description: "Should reject nil values",
-		},
-		{
-			name:        "Empty string attempt",
-			clearDays:   "",
-			expectError: true,
-			description: "Should reject empty strings",
-		},
-		{
-			name:        "Hexadecimal injection attempt",
-			clearDays:   "0x1F",
-			expectError: true,
-			description: "Should reject hexadecimal values",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			// Test the input validation function that should be implemented
-			err := validateClearDaysInput(tt.clearDays)
-
-			if tt.expectError {
-				suite.Error(err, "Expected error for input: %v (%s)", tt.clearDays, tt.description)
-				if err != nil {
-					// Verify error message doesn't leak sensitive information
-					suite.NotContains(strings.ToLower(err.Error()), "sql")
-					suite.NotContains(strings.ToLower(err.Error()), "injection")
-					suite.NotContains(strings.ToLower(err.Error()), "query")
-				}
-			} else {
-				suite.NoError(err, "Expected no error for input: %v (%s)", tt.clearDays, tt.description)
-			}
-		})
-	}
-}
-
-// TestEventCleanerParameterizedQueries tests that queries use parameterized statements
-func (suite *EventsSecurityTestSuite) TestEventCleanerParameterizedQueries() {
-	// This test verifies that the delQueries are properly parameterized
-	// and don't use string formatting that could lead to SQL injection
-
-	suite.Run("Queries should use parameterized placeholders", func() {
-		// Get the delQueries from the main package
-		// This assumes delQueries is accessible for testing
-		queries := getDelQueries() // This function should be implemented to return delQueries
-
-		for i, query := range queries {
-			suite.Run(fmt.Sprintf("Query_%d", i), func() {
-				// Check that query uses proper parameterization ($1, $2, etc.)
-				// instead of %s, %d, etc.
-				suite.NotContains(query, "%s", "Query should not use string formatting: %s", query)
-				suite.NotContains(query, "%d", "Query should not use decimal formatting: %s", query)
-				suite.NotContains(query, "%v", "Query should not use value formatting: %s", query)
-
-				// Verify it uses proper PostgreSQL parameterization
-				suite.Contains(query, "$1", "Query should use parameterized placeholder $1: %s", query)
-
-				// Ensure query structure is as expected
-				suite.True(strings.Contains(query, "DELETE") || strings.Contains(query, "UPDATE"),
-					"Query should be DELETE or UPDATE operation: %s", query)
-			})
-		}
-	})
-}
-
-// TestEventCleanerConcurrentSQLInjection tests SQL injection under concurrent conditions
-func (suite *EventsSecurityTestSuite) TestEventCleanerConcurrentSQLInjection() {
-	maliciousInputs := []interface{}{
-		"1'; DROP TABLE events; --",
-		"1 OR 1=1",
-		"'; TRUNCATE events; --",
-	}
-
-	suite.Run("Concurrent malicious inputs should all be rejected", func() {
-		done := make(chan error, len(maliciousInputs))
-
-		for _, input := range maliciousInputs {
-			go func(val interface{}) {
-				err := validateClearDaysInput(val)
-				done <- err
-			}(input)
-		}
-
-		// Collect all results
-		for i := 0; i < len(maliciousInputs); i++ {
-			err := <-done
-			suite.Error(err, "All malicious inputs should be rejected concurrently")
-		}
-	})
-}
-
-// TestEventCleanerInputSanitization tests input sanitization effectiveness
-func (suite *EventsSecurityTestSuite) TestEventCleanerInputSanitization() {
-	tests := []struct {
-		input    interface{}
-		name     string
-		expected int
-		hasError bool
-	}{
-		{
-			name:     "Clean integer conversion",
-			input:    "30",
-			expected: 30,
-			hasError: false,
-		},
-		{
-			name:     "Integer with whitespace",
-			input:    "  30  ",
-			expected: 30,
-			hasError: false,
-		},
-		{
-			name:     "Malicious string should error",
-			input:    "30'; DROP TABLE --",
-			expected: 0,
-			hasError: true,
-		},
-		{
-			name:     "Non-numeric string should error",
-			input:    "abc",
-			expected: 0,
-			hasError: true,
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result, err := sanitizeAndValidateClearDays(tt.input)
-
-			if tt.hasError {
-				suite.Error(err)
-			} else {
-				suite.NoError(err)
-				suite.Equal(tt.expected, result)
-			}
-		})
-	}
-}
-
-// TestEventCleanerDatabaseInteraction tests secure database interaction patterns
-func (suite *EventsSecurityTestSuite) TestEventCleanerDatabaseInteraction() {
-	// This test would use a real test database in a complete implementation
-	// For now, we test the security aspects of the interaction patterns
-
-	suite.Run("Database queries should use context with timeout", func() {
-		ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-
-		// Test that the context is properly used and respected
-		// This prevents long-running malicious queries
-		done := make(chan bool)
-		go func() {
-			// Simulate a long-running query that should be cancelled
-			select {
-			case <-ctx.Done():
-				done <- true
-			case <-time.After(10 * time.Second):
-				done <- false
-			}
-		}()
-
-		result := <-done
-		suite.True(result, "Context timeout should be respected")
-	})
-}
-
-// Mock implementations for testing - removed as not needed for current tests
-
-// Helper functions that should be implemented in the main codebase
-
-// validateClearDaysInput validates and sanitizes the clearDays input
-func validateClearDaysInput(input interface{}) error {
-	// This function should be implemented in the main codebase
-	// to validate clearDays input before using it in SQL queries
-
-	switch v := input.(type) {
-	case int:
-		if v < 0 || v > 365 {
-			return fmt.Errorf("invalid range: must be between 0 and 365")
-		}
-		return nil
-	case string:
-		// Check for SQL injection patterns
-		sqlPatterns := []string{
-			"'", "\"", ";", "--", "/*", "*/", "xp_", "sp_",
-			"SELECT", "INSERT", "UPDATE", "DELETE", "DROP", "CREATE",
-			"ALTER", "EXEC", "EXECUTE", "UNION", "OR", "AND",
-		}
-
-		upperInput := strings.ToUpper(strings.TrimSpace(v))
-		for _, pattern := range sqlPatterns {
-			if strings.Contains(upperInput, strings.ToUpper(pattern)) {
-				return fmt.Errorf("invalid input: contains forbidden characters")
-			}
-		}
-		// Check for hexadecimal patterns
-		if strings.HasPrefix(strings.ToLower(strings.TrimSpace(v)), "0x") {
-			return fmt.Errorf("invalid input: hexadecimal values not allowed")
-		}
-
-		// Try to convert to int
-		if _, err := fmt.Sscanf(strings.TrimSpace(v), "%d", new(int)); err != nil {
-			return fmt.Errorf("invalid input: not a valid integer")
-		}
-		return validateClearDaysInput(mustParseInt(strings.TrimSpace(v)))
-	default:
-		return fmt.Errorf("invalid input type: expected int or string")
-	}
-}
-
-// sanitizeAndValidateClearDays sanitizes and validates the input, returning the clean integer
-func sanitizeAndValidateClearDays(input interface{}) (int, error) {
-	err := validateClearDaysInput(input)
-	if err != nil {
-		return 0, err
-	}
-
-	switch v := input.(type) {
-	case int:
-		return v, nil
-	case string:
-		return mustParseInt(strings.TrimSpace(v)), nil
-	default:
-		return 0, fmt.Errorf("unsupported type")
-	}
-}
-
-// getDelQueries returns the deletion queries for testing
-func getDelQueries() []string {
-	// This should return the actual delQueries from the main package
-	// For testing purposes, we return expected parameterized queries
-	return []string{
-		"DELETE FROM hdb_catalog.event_log WHERE created_at < NOW() - $1::INTERVAL",
-		"DELETE FROM hdb_catalog.event_invocation_logs WHERE created_at < NOW() - $1::INTERVAL",
-	}
-}
-
-// mustParseInt parses an integer from string, panicking on error (for testing)
-func mustParseInt(s string) int {
-	var result int
-	if _, err := fmt.Sscanf(s, "%d", &result); err != nil {
-		panic(fmt.Sprintf("failed to parse integer: %v", err))
-	}
-	return result
-}

events_test.go

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

fasthttp_client_test.go

@@ -1,523 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"runtime"
-	"sync"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	"github.com/stretchr/testify/assert"
-	"github.com/valyala/fasthttp"
-)
-
-// Tests for fasthttp client configuration and behavior
-
-// TestFasthttpClientConfiguration tests that the client is properly configured
-// with different timeout settings and other configuration options
-func (suite *Tests) TestFasthttpClientConfiguration() {
-	// Test various configurations
-	testConfigs := []struct {
-		name             string
-		clientTimeout    int
-		readTimeout      int
-		writeTimeout     int
-		maxConnsPerHost  int
-		disableTLSVerify bool
-	}{
-		{
-			name:             "short_timeouts",
-			clientTimeout:    1,
-			readTimeout:      1,
-			writeTimeout:     1,
-			maxConnsPerHost:  100,
-			disableTLSVerify: false,
-		},
-		{
-			name:             "long_timeouts",
-			clientTimeout:    30,
-			readTimeout:      20,
-			writeTimeout:     10,
-			maxConnsPerHost:  500,
-			disableTLSVerify: true,
-		},
-		{
-			name:             "high_concurrency",
-			clientTimeout:    5,
-			readTimeout:      5,
-			writeTimeout:     5,
-			maxConnsPerHost:  2000,
-			disableTLSVerify: false,
-		},
-	}
-
-	for _, tc := range testConfigs {
-		suite.Run(tc.name, func() {
-			// Create config with test values
-			testConfig := &config{}
-			testConfig.Client.ClientTimeout = tc.clientTimeout
-			testConfig.Client.ReadTimeout = tc.readTimeout
-			testConfig.Client.WriteTimeout = tc.writeTimeout
-			testConfig.Client.MaxConnsPerHost = tc.maxConnsPerHost
-			testConfig.Client.DisableTLSVerify = tc.disableTLSVerify
-			testConfig.Client.MaxIdleConnDuration = 10
-
-			// Create client and verify configuration
-			client := createFasthttpClient(testConfig)
-
-			// We can't easily access private fields of the client, but we can verify it works
-			// with the configured timeouts by testing requests
-			assert.NotNil(suite.T(), client, "Client should be created")
-
-			// For non-zero configuration values, we can at least verify they were applied
-			// by checking the client isn't nil
-			assert.NotNil(suite.T(), client.TLSConfig, "TLS config should be created")
-		})
-	}
-}
-
-// TestClientTimeoutBehavior tests that the client respects configured timeouts
-func (suite *Tests) TestClientTimeoutBehavior() {
-	// Create a test server that simulates different response times
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Get sleep duration from header
-		sleepDurationHeader := r.Header.Get("X-Sleep-Duration")
-		var sleepDuration time.Duration
-		if sleepDurationHeader != "" {
-			sleepDuration, _ = time.ParseDuration(sleepDurationHeader)
-		}
-
-		// Sleep for the specified duration
-		time.Sleep(sleepDuration)
-
-		// Return a simple JSON response
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"data":{"test":"response"}}`))
-	}))
-	defer server.Close()
-
-	testCases := []struct {
-		name          string
-		sleepDuration string
-		clientTimeout int
-		shouldTimeout bool
-	}{
-		{
-			name:          "within_timeout",
-			clientTimeout: 2,
-			sleepDuration: "1s",
-			shouldTimeout: false,
-		},
-		{
-			name:          "exceeds_timeout",
-			clientTimeout: 1,
-			sleepDuration: "2s",
-			shouldTimeout: true,
-		},
-		{
-			name:          "at_timeout_boundary",
-			clientTimeout: 3,
-			sleepDuration: "2.5s",
-			shouldTimeout: false, // Increased buffer to reduce flakiness under race detection
-		},
-	}
-
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			// Skip timing-sensitive boundary test as it's inherently flaky and already acknowledged by developers
-			if tc.name == "at_timeout_boundary" {
-				suite.T().Skip("Skipping inherently flaky timing boundary test that was noted as potentially problematic in CI")
-			}
-
-			// Store original client and restore after test
-			originalClient := cfg.Client.FastProxyClient
-			originalTimeout := cfg.Client.ClientTimeout
-			defer func() {
-				cfg.Client.FastProxyClient = originalClient
-				cfg.Client.ClientTimeout = originalTimeout
-			}()
-
-			// Configure client with test timeout
-			cfg.Client.ClientTimeout = tc.clientTimeout
-			cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-			// Configure server URL
-			cfg.Server.HostGraphQL = server.URL
-
-			// Create request context
-			reqCtx := &fasthttp.RequestCtx{}
-			reqCtx.Request.SetRequestURI("/graphql")
-			reqCtx.Request.Header.SetMethod("POST")
-			reqCtx.Request.Header.Set("Content-Type", "application/json")
-			reqCtx.Request.Header.Set("X-Sleep-Duration", tc.sleepDuration)
-			reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-			// Create fiber context
-			ctx := suite.app.AcquireCtx(reqCtx)
-			defer suite.app.ReleaseCtx(ctx)
-
-			// Call the proxy function
-			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-			// Verify timeout behavior
-			if tc.shouldTimeout {
-				assert.NotNil(suite.T(), err, "Request should timeout")
-				if err != nil {
-					assert.Contains(suite.T(), err.Error(), "timeout", "Error should mention timeout")
-				}
-			} else {
-				assert.Nil(suite.T(), err, "Request should not timeout")
-				assert.Equal(suite.T(), fiber.StatusOK, ctx.Response().StatusCode(), "Status should be 200 OK")
-			}
-		})
-	}
-}
-
-// TestConcurrentRequestHandling tests how the proxy handles concurrent requests
-func (suite *Tests) TestConcurrentRequestHandling() {
-	// Create a test server that returns different responses based on request count
-	var requestCount int
-	var requestMutex sync.Mutex
-
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		requestMutex.Lock()
-		requestCount++
-		currentRequest := requestCount
-		requestMutex.Unlock()
-
-		// Introduce varying delays to simulate real-world conditions
-		delay := time.Duration(currentRequest%5) * 100 * time.Millisecond
-		time.Sleep(delay)
-
-		// Return a response with the request number
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = fmt.Fprintf(w, `{"data":{"request":%d}}`, currentRequest)
-	}))
-	defer server.Close()
-
-	// Store original client and restore after test
-	originalClient := cfg.Client.FastProxyClient
-	defer func() {
-		cfg.Client.FastProxyClient = originalClient
-	}()
-
-	// Configure client for concurrent requests
-	cfg.Client.MaxConnsPerHost = 100 // Allow plenty of concurrent connections
-	cfg.Client.ClientTimeout = 5     // Generous timeout
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-	// Configure server URL
-	cfg.Server.HostGraphQL = server.URL
-
-	// Number of concurrent requests to make
-	numRequests := 50
-
-	// Results channel to collect responses
-	results := make(chan struct {
-		err      error
-		response []byte
-		index    int
-	}, numRequests)
-
-	// WaitGroup to ensure all goroutines complete
-	var wg sync.WaitGroup
-	wg.Add(numRequests)
-
-	// Launch concurrent requests
-	for i := 0; i < numRequests; i++ {
-		go func(index int) {
-			defer wg.Done()
-
-			// Create request context
-			reqCtx := &fasthttp.RequestCtx{}
-			reqCtx.Request.SetRequestURI("/graphql")
-			reqCtx.Request.Header.SetMethod("POST")
-			reqCtx.Request.Header.Set("Content-Type", "application/json")
-			reqCtx.Request.SetBody([]byte(fmt.Sprintf(`{"query": "query { request(%d) }", "index": %d}`, index, index)))
-
-			// Create fiber context
-			ctx := suite.app.AcquireCtx(reqCtx)
-			defer suite.app.ReleaseCtx(ctx)
-
-			// Call the proxy function
-			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-			// Collect results
-			results <- struct {
-				err      error
-				response []byte
-				index    int
-			}{
-				index:    index,
-				response: ctx.Response().Body(),
-				err:      err,
-			}
-		}(i)
-	}
-
-	// Start a goroutine to close the results channel when all requests are done
-	go func() {
-		wg.Wait()
-		close(results)
-	}()
-
-	// Collect all results
-	successCount := 0
-	errorCount := 0
-
-	for result := range results {
-		if result.err != nil {
-			errorCount++
-		} else {
-			successCount++
-			assert.NotEmpty(suite.T(), result.response, "Response should not be empty")
-			assert.Contains(suite.T(), string(result.response), "request", "Response should contain request data")
-		}
-	}
-
-	// Verify all requests were processed
-	assert.Equal(suite.T(), numRequests, successCount+errorCount, "All requests should be processed")
-
-	// Expecting all or most requests to succeed
-	assert.GreaterOrEqual(suite.T(), successCount, numRequests*9/10,
-		"At least 90% of requests should succeed")
-
-	// Log the success ratio
-	suite.T().Logf("Concurrent request test: %d/%d requests succeeded (%0.2f%%)",
-		successCount, numRequests, float64(successCount)/float64(numRequests)*100)
-}
-
-// TestMaxConcurrentConnections tests the behavior when reaching the maximum connection limit
-func (suite *Tests) TestMaxConcurrentConnections() {
-	// Skip this test as it's inherently subject to race conditions when testing concurrent connection limits
-	suite.T().Skip("Skipping concurrent connection limit test due to inherent race conditions under race detection")
-
-	// Skip on low CPU systems to avoid test flakiness
-	if runtime.NumCPU() < 4 {
-		suite.T().Skip("Skipping connection limit test on system with less than 4 CPUs")
-	}
-
-	// Create a test server that sleeps to keep connections open
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Sleep for a significant time to keep connections open
-		time.Sleep(2 * time.Second)
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"data":{"test":"response"}}`))
-	}))
-	defer server.Close()
-
-	// Store original client and restore after test
-	originalClient := cfg.Client.FastProxyClient
-	originalMaxConns := cfg.Client.MaxConnsPerHost
-	defer func() {
-		cfg.Client.FastProxyClient = originalClient
-		cfg.Client.MaxConnsPerHost = originalMaxConns
-	}()
-
-	// Configure client with a very low connection limit
-	cfg.Client.MaxConnsPerHost = 5 // Only allow 5 concurrent connections
-	cfg.Client.ClientTimeout = 5
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-	// Configure server URL
-	cfg.Server.HostGraphQL = server.URL
-
-	// Number of concurrent requests - significantly more than our connection limit
-	numRequests := 20
-
-	// Results channel to collect responses
-	results := make(chan struct {
-		err      error
-		response []byte
-		index    int
-		status   int
-	}, numRequests)
-
-	// WaitGroup to ensure all goroutines complete
-	var wg sync.WaitGroup
-	wg.Add(numRequests)
-
-	// Buffer to capture log output
-	var logBuffer bytes.Buffer
-	originalLogger := cfg.Logger
-	cfg.Logger = originalLogger.SetOutput(&logBuffer)
-	defer func() {
-		cfg.Logger = originalLogger
-	}()
-
-	// Launch concurrent requests
-	for i := 0; i < numRequests; i++ {
-		go func(index int) {
-			defer wg.Done()
-
-			// Create request context
-			reqCtx := &fasthttp.RequestCtx{}
-			reqCtx.Request.SetRequestURI("/graphql")
-			reqCtx.Request.Header.SetMethod("POST")
-			reqCtx.Request.Header.Set("Content-Type", "application/json")
-			reqCtx.Request.SetBody([]byte(fmt.Sprintf(`{"query": "query { test(%d) }"}`, index)))
-
-			// Create fiber context
-			ctx := suite.app.AcquireCtx(reqCtx)
-			defer suite.app.ReleaseCtx(ctx)
-
-			// Call the proxy function
-			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-			// Collect results
-			results <- struct {
-				err      error
-				response []byte
-				index    int
-				status   int
-			}{
-				index:    index,
-				response: ctx.Response().Body(),
-				status:   ctx.Response().StatusCode(),
-				err:      err,
-			}
-		}(i)
-
-		// Small delay to ensure the requests don't all start exactly at the same time
-		// which could lead to unpredictable behavior of the connection pool
-		time.Sleep(10 * time.Millisecond)
-	}
-
-	// Start a goroutine to close the results channel when all requests are done
-	go func() {
-		wg.Wait()
-		close(results)
-	}()
-
-	// Collect all results
-	successCount := 0
-	errorCount := 0
-
-	for result := range results {
-		if result.err != nil {
-			errorCount++
-		} else {
-			successCount++
-		}
-	}
-
-	// Verify all requests were processed
-	assert.Equal(suite.T(), numRequests, successCount+errorCount, "All requests should be processed")
-
-	// We expect some requests to succeed and some to fail or be delayed due to the connection limit
-	// The exact behavior depends on the implementation of fasthttp client's connection pool
-	// and the operating system's TCP stack configuration.
-
-	// Log the success ratio
-	suite.T().Logf("Max connections test: %d/%d requests succeeded, %d failed/retried",
-		successCount, numRequests, errorCount)
-}
-
-// TestVariousResponseTypes tests handling of different response types
-func (suite *Tests) TestVariousResponseTypes() {
-	testCases := []struct {
-		name          string
-		contentType   string
-		responseBody  string
-		expectedError string
-		statusCode    int
-		expectError   bool
-	}{
-		{
-			name:         "json_success",
-			contentType:  "application/json",
-			statusCode:   http.StatusOK,
-			responseBody: `{"data":{"test":"success"}}`,
-			expectError:  false,
-		},
-		{
-			name:          "json_error",
-			contentType:   "application/json",
-			statusCode:    http.StatusBadRequest,
-			responseBody:  `{"errors":[{"message":"Invalid query"}]}`,
-			expectError:   true,
-			expectedError: "received non-200 response",
-		},
-		{
-			name:         "plain_text",
-			contentType:  "text/plain",
-			statusCode:   http.StatusOK,
-			responseBody: "OK",
-			expectError:  false,
-		},
-		{
-			name:          "html_error",
-			contentType:   "text/html",
-			statusCode:    http.StatusInternalServerError,
-			responseBody:  "<html><body><h1>500 Server Error</h1></body></html>",
-			expectError:   true,
-			expectedError: "received non-200 response",
-		},
-		{
-			name:         "empty_response",
-			contentType:  "application/json",
-			statusCode:   http.StatusOK,
-			responseBody: "",
-			expectError:  false,
-		},
-	}
-
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			// Create a test server with the current test configuration
-			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-				w.Header().Set("Content-Type", tc.contentType)
-				w.WriteHeader(tc.statusCode)
-				_, _ = w.Write([]byte(tc.responseBody))
-			}))
-			defer server.Close()
-
-			// Store original client and restore after test
-			originalClient := cfg.Client.FastProxyClient
-			defer func() {
-				cfg.Client.FastProxyClient = originalClient
-			}()
-
-			// Configure client for test
-			cfg.Client.ClientTimeout = 5
-			cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-			// Configure server URL
-			cfg.Server.HostGraphQL = server.URL
-
-			// Create request context
-			reqCtx := &fasthttp.RequestCtx{}
-			reqCtx.Request.SetRequestURI("/graphql")
-			reqCtx.Request.Header.SetMethod("POST")
-			reqCtx.Request.Header.Set("Content-Type", "application/json")
-			reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-			// Create fiber context
-			ctx := suite.app.AcquireCtx(reqCtx)
-			defer suite.app.ReleaseCtx(ctx)
-
-			// Call the proxy function
-			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-			// Verify response handling
-			if tc.expectError {
-				assert.NotNil(suite.T(), err, "proxyTheRequest should return error")
-				if tc.expectedError != "" {
-					assert.Contains(suite.T(), err.Error(), tc.expectedError,
-						"Error should contain expected message")
-				}
-			} else {
-				assert.Nil(suite.T(), err, "proxyTheRequest should not return error")
-				assert.Equal(suite.T(), tc.statusCode, ctx.Response().StatusCode(),
-					"Response status should match expected")
-				assert.Equal(suite.T(), tc.responseBody, string(ctx.Response().Body()),
-					"Response body should match expected")
-			}
-		})
-	}
-}

go.mod

@@ -1,74 +1,71 @@
 module github.com/lukaszraczylo/graphql-monitoring-proxy
 
-go 1.24.0
+go 1.22.7
 
-toolchain go1.24.6
+toolchain go1.23.4
 
 require (
-	github.com/VictoriaMetrics/metrics v1.40.2
+	github.com/VictoriaMetrics/metrics v1.35.2
 	github.com/alicebob/miniredis/v2 v2.33.0
-	github.com/avast/retry-go/v4 v4.7.0
+	github.com/avast/retry-go/v4 v4.6.0
 	github.com/goccy/go-json v0.10.5
-	github.com/gofiber/fiber/v2 v2.52.10
-	github.com/gofiber/websocket/v2 v2.2.1
-	github.com/gofrs/flock v0.13.0
+	github.com/gofiber/fiber/v2 v2.52.6
+	github.com/gofrs/flock v0.12.1
 	github.com/google/uuid v1.6.0
-	github.com/gookit/goutil v0.7.2
-	github.com/gorilla/websocket v1.5.3
+	github.com/gookit/goutil v0.6.18
 	github.com/graphql-go/graphql v0.8.1
-	github.com/jackc/pgx/v5 v5.7.6
+	github.com/jackc/pgx/v5 v5.7.2
 	github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9
 	github.com/lukaszraczylo/go-ratecounter v0.1.12
-	github.com/lukaszraczylo/go-simple-graphql v1.2.89
-	github.com/redis/go-redis/v9 v9.17.2
-	github.com/sony/gobreaker v1.0.0
-	github.com/stretchr/testify v1.11.1
-	github.com/valyala/fasthttp v1.68.0
-	go.opentelemetry.io/otel v1.38.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0
-	go.opentelemetry.io/otel/sdk v1.38.0
-	go.opentelemetry.io/otel/trace v1.38.0
-	google.golang.org/grpc v1.77.0
+	github.com/lukaszraczylo/go-simple-graphql v1.2.41
+	github.com/redis/go-redis/v9 v9.7.0
+	github.com/stretchr/testify v1.10.0
+	github.com/valyala/fasthttp v1.58.0
+	go.opentelemetry.io/otel v1.34.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.34.0
+	go.opentelemetry.io/otel/sdk v1.34.0
+	go.opentelemetry.io/otel/trace v1.34.0
+	google.golang.org/grpc v1.70.0
 )
 
 require (
 	github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a // indirect
-	github.com/andybalholm/brotli v1.2.0 // indirect
-	github.com/cenkalti/backoff/v5 v5.0.3 // indirect
+	github.com/andybalholm/brotli v1.1.1 // indirect
+	github.com/cenkalti/backoff/v4 v4.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/clipperhouse/stringish v0.1.1 // indirect
-	github.com/clipperhouse/uax29/v2 v2.3.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/fasthttp/websocket v1.5.12 // indirect
-	github.com/go-logr/logr v1.4.3 // indirect
+	github.com/go-logr/logr v1.4.2 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 // indirect
+	github.com/gookit/color v1.5.4 // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.0 // indirect
 	github.com/jackc/pgpassfile v1.0.0 // indirect
 	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
 	github.com/jackc/puddle/v2 v2.2.2 // indirect
-	github.com/klauspost/compress v1.18.2 // indirect
+	github.com/klauspost/compress v1.17.11 // indirect
 	github.com/mattn/go-colorable v0.1.14 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
-	github.com/mattn/go-runewidth v0.0.19 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/savsgio/gotils v0.0.0-20250924091648-bce9a52d7761 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
 	github.com/valyala/bytebufferpool v1.0.0 // indirect
 	github.com/valyala/fastrand v1.1.0 // indirect
 	github.com/valyala/histogram v1.2.0 // indirect
+	github.com/valyala/tcplisten v1.0.0 // indirect
+	github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e // indirect
 	github.com/yuin/gopher-lua v1.1.1 // indirect
-	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 // indirect
-	go.opentelemetry.io/otel/metric v1.38.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.9.0 // indirect
-	golang.org/x/crypto v0.45.0 // indirect
-	golang.org/x/net v0.47.0 // indirect
-	golang.org/x/sync v0.18.0 // indirect
-	golang.org/x/sys v0.38.0 // indirect
-	golang.org/x/term v0.37.0 // indirect
-	golang.org/x/text v0.31.0 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20251202230838-ff82c1b0f217 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 // indirect
-	google.golang.org/protobuf v1.36.10 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.34.0 // indirect
+	go.opentelemetry.io/otel/metric v1.34.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.5.0 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+	golang.org/x/net v0.34.0 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/term v0.29.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250204164813-702378808489 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 // indirect
+	google.golang.org/protobuf v1.36.5 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,71 +1,63 @@
-github.com/VictoriaMetrics/metrics v1.40.2 h1:OVSjKcQEx6JAwGeu8/KQm9Su5qJ72TMEW4xYn5vw3Ac=
-github.com/VictoriaMetrics/metrics v1.40.2/go.mod h1:XE4uudAAIRaJE614Tl5HMrtoEU6+GDZO4QTnNSsZRuA=
+github.com/VictoriaMetrics/metrics v1.35.2 h1:Bj6L6ExfnakZKYPpi7mGUnkJP4NGQz2v5wiChhXNyWQ=
+github.com/VictoriaMetrics/metrics v1.35.2/go.mod h1:r7hveu6xMdUACXvB8TYdAj8WEsKzWB0EkpJN+RDtOf8=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a h1:HbKu58rmZpUGpz5+4FfNmIU+FmZg2P3Xaj2v2bfNWmk=
 github.com/alicebob/gopher-json v0.0.0-20200520072559-a9ecdc9d1d3a/go.mod h1:SGnFV6hVsYE877CKEZ6tDNTjaSXYUk6QqoIK6PrAtcc=
 github.com/alicebob/miniredis/v2 v2.33.0 h1:uvTF0EDeu9RLnUEG27Db5I68ESoIxTiXbNUiji6lZrA=
 github.com/alicebob/miniredis/v2 v2.33.0/go.mod h1:MhP4a3EU7aENRi9aO+tHfTBZicLqQevyi/DJpoj6mi0=
-github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
-github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
-github.com/avast/retry-go/v4 v4.7.0 h1:yjDs35SlGvKwRNSykujfjdMxMhMQQM0TnIjJaHB+Zio=
-github.com/avast/retry-go/v4 v4.7.0/go.mod h1:ZMPDa3sY2bKgpLtap9JRUgk2yTAba7cgiFhqxY2Sg6Q=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
+github.com/avast/retry-go/v4 v4.6.0 h1:K9xNA+KeB8HHc2aWFuLb25Offp+0iVRXEvFx8IinRJA=
+github.com/avast/retry-go/v4 v4.6.0/go.mod h1:gvWlPhBVsvBbLkVGDg/KwvBv0bEkCOLRRSHKIr2PyOE=
 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs=
 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c=
 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=
 github.com/bsm/gomega v1.27.10/go.mod h1:JyEr/xRbxbtgWNi8tIEVPUYZ5Dzef52k01W3YH0H+O0=
-github.com/cenkalti/backoff/v5 v5.0.3 h1:ZN+IMa753KfX5hd8vVaMixjnqRZ3y8CuJKRKj1xcsSM=
-github.com/cenkalti/backoff/v5 v5.0.3/go.mod h1:rkhZdG3JZukswDf7f0cwqPNk4K0sa+F97BxZthm/crw=
+github.com/cenkalti/backoff/v4 v4.3.0 h1:MyRJ/UdXutAwSAT+s3wNd7MfTIcy71VQueUuFK343L8=
+github.com/cenkalti/backoff/v4 v4.3.0/go.mod h1:Y3VNntkOUPxTVeUxJ/G5vcM//AlwfmyYozVcomhLiZE=
 github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/clipperhouse/stringish v0.1.1 h1:+NSqMOr3GR6k1FdRhhnXrLfztGzuG+VuFDfatpWHKCs=
-github.com/clipperhouse/stringish v0.1.1/go.mod h1:v/WhFtE1q0ovMta2+m+UbpZ+2/HEXNWYXQgCt4hdOzA=
-github.com/clipperhouse/uax29/v2 v2.3.0 h1:SNdx9DVUqMoBuBoW3iLOj4FQv3dN5mDtuqwuhIGpJy4=
-github.com/clipperhouse/uax29/v2 v2.3.0/go.mod h1:Wn1g7MK6OoeDT0vL+Q0SQLDz/KpfsVRgg6W7ihQeh4g=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
 github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/fasthttp/websocket v1.5.12 h1:e4RGPpWW2HTbL3zV0Y/t7g0ub294LkiuXXUuTOUInlE=
-github.com/fasthttp/websocket v1.5.12/go.mod h1:I+liyL7/4moHojiOgUOIKEWm9EIxHqxZChS+aMFltyg=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
+github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
 github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
 github.com/goccy/go-json v0.10.5 h1:Fq85nIqj+gXn/S5ahsiTlK3TmC85qgirsdTP/+DeaC4=
 github.com/goccy/go-json v0.10.5/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
 github.com/goccy/go-reflect v1.2.0 h1:O0T8rZCuNmGXewnATuKYnkL0xm6o8UNOJZd/gOkb9ms=
 github.com/goccy/go-reflect v1.2.0/go.mod h1:n0oYZn8VcV2CkWTxi8B9QjkCoq6GTtCEdfmR66YhFtE=
-github.com/gofiber/fiber/v2 v2.52.10 h1:jRHROi2BuNti6NYXmZ6gbNSfT3zj/8c0xy94GOU5elY=
-github.com/gofiber/fiber/v2 v2.52.10/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw=
-github.com/gofiber/websocket/v2 v2.2.1 h1:C9cjxvloojayOp9AovmpQrk8VqvVnT8Oao3+IUygH7w=
-github.com/gofiber/websocket/v2 v2.2.1/go.mod h1:Ao/+nyNnX5u/hIFPuHl28a+NIkrqK7PRimyKaj4JxVU=
-github.com/gofrs/flock v0.13.0 h1:95JolYOvGMqeH31+FC7D2+uULf6mG61mEZ/A8dRYMzw=
-github.com/gofrs/flock v0.13.0/go.mod h1:jxeyy9R1auM5S6JYDBhDt+E2TCo7DkratH4Pgi8P+Z0=
+github.com/gofiber/fiber/v2 v2.52.6 h1:Rfp+ILPiYSvvVuIPvxrBns+HJp8qGLDnLJawAu27XVI=
+github.com/gofiber/fiber/v2 v2.52.6/go.mod h1:YEcBbO/FB+5M1IZNBP9FO3J9281zgPAreiI1oqg8nDw=
+github.com/gofrs/flock v0.12.1 h1:MTLVXXHf8ekldpJk3AKicLij9MdwOWkZ+a/jHHZby9E=
+github.com/gofrs/flock v0.12.1/go.mod h1:9zxTsyu5xtJ9DK+1tFZyibEV7y3uwDxPPfbxeeHCoD0=
 github.com/golang/protobuf v1.5.4 h1:i7eJL8qZTpSEXOPTxNKhASYpMn+8e5Q6AdndVa1dWek=
 github.com/golang/protobuf v1.5.4/go.mod h1:lnTiLA8Wa4RWRcIUkrtSVa5nRhsEGBg48fD6rSs7xps=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
-github.com/gookit/goutil v0.7.2 h1:NSiqWWY+BT0MwIlKDeSVPfQmr9xTkkAqwDjhplobdgo=
-github.com/gookit/goutil v0.7.2/go.mod h1:vJS9HXctYTCLtCsZot5L5xF+O1oR17cDYO9R0HxBmnU=
-github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
+github.com/gookit/color v1.5.4 h1:FZmqs7XOyGgCAxmWyPslpiok1k05wmY3SJTytgvYFs0=
+github.com/gookit/color v1.5.4/go.mod h1:pZJOeOS8DM43rXbp4AZo1n9zCU2qjpcRko0b6/QJi9w=
+github.com/gookit/goutil v0.6.18 h1:MUVj0G16flubWT8zYVicIuisUiHdgirPAkmnfD2kKgw=
+github.com/gookit/goutil v0.6.18/go.mod h1:AY/5sAwKe7Xck+mEbuxj0n/bc3qwrGNe3Oeulln7zBA=
 github.com/graphql-go/graphql v0.8.1 h1:p7/Ou/WpmulocJeEx7wjQy611rtXGQaAcXGqanuMMgc=
 github.com/graphql-go/graphql v0.8.1/go.mod h1:nKiHzRM0qopJEwCITUuIsxk9PlVlwIiiI8pnJEhordQ=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3 h1:NmZ1PKzSTQbuGHw9DGPFomqkkLWMC+vZCkfs+FHv1Vg=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.3/go.mod h1:zQrxl1YP88HQlA6i9c63DSVPFklWpGX4OWAc9bFuaH4=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.0 h1:VD1gqscl4nYs1YxVuSdemTrSgTKrwOWDK0FVFMqm+Cg=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.0/go.mod h1:4EgsQoS4TOhJizV+JTFg40qx1Ofh3XmXEQNBpgvNT40=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
 github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
-github.com/jackc/pgx/v5 v5.7.6 h1:rWQc5FwZSPX58r1OQmkuaNicxdmExaEz5A2DO2hUuTk=
-github.com/jackc/pgx/v5 v5.7.6/go.mod h1:aruU7o91Tc2q2cFp5h4uP3f6ztExVpyVv88Xl/8Vl8M=
+github.com/jackc/pgx/v5 v5.7.2 h1:mLoDLV6sonKlvjIEsV56SkWNCnuNv531l94GaIzO+XI=
+github.com/jackc/pgx/v5 v5.7.2/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
 github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
 github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
-github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk=
-github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4=
+github.com/klauspost/compress v1.17.11 h1:In6xLpyWOi1+C7tXUUWv2ot1QvBjxevKAaI6IXrJmUc=
+github.com/klauspost/compress v1.17.11/go.mod h1:pMDklpSncoRMuLFrf1W9Ss9KT+0rH90U12bZKk7uwG0=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
 github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
 github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
@@ -74,84 +66,87 @@ github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9 h1:pL8B9mjv6RPUf
 github.com/lukaszraczylo/ask v0.0.0-20240916204100-6e9ef53a62d9/go.mod h1:M+UVdyqZs++xtEPrascaVmZdOMhCnxjZ2SgH+xHpR0c=
 github.com/lukaszraczylo/go-ratecounter v0.1.12 h1:VO6hHYGw/Jy9JUizXf/bS0AI2QX1ueWWAWckMFVJ/w4=
 github.com/lukaszraczylo/go-ratecounter v0.1.12/go.mod h1:TqXEOCtFJStk1i0tkipprv1kiDHGon1MVUisjSTBSKM=
-github.com/lukaszraczylo/go-simple-graphql v1.2.89 h1:Xbu1Ny+a0lT2Sr2SaSC8mcHmGQDwGD4TJKk4DDd+PwA=
-github.com/lukaszraczylo/go-simple-graphql v1.2.89/go.mod h1:PxQYblQDZISmYYj8sNfazAWxAOh1rhAtU208y+uPV8s=
+github.com/lukaszraczylo/go-simple-graphql v1.2.41 h1:RNFEjntCsjvKA5VADdio3zid3nH0+rO9qdKJvXmRpfQ=
+github.com/lukaszraczylo/go-simple-graphql v1.2.41/go.mod h1:i0R9B7tR025qduN4/t6ujolMBdWyiMlAppqczrnPfLc=
 github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
 github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
-github.com/mattn/go-runewidth v0.0.19 h1:v++JhqYnZuu5jSKrk9RbgF5v4CGUjqRfBm05byFGLdw=
-github.com/mattn/go-runewidth v0.0.19/go.mod h1:XBkDxAl56ILZc9knddidhrOlY5R/pDhgLpndooCuJAs=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/redis/go-redis/v9 v9.17.2 h1:P2EGsA4qVIM3Pp+aPocCJ7DguDHhqrXNhVcEp4ViluI=
-github.com/redis/go-redis/v9 v9.17.2/go.mod h1:u410H11HMLoB+TP67dz8rL9s6QW2j76l0//kSOd3370=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
-github.com/savsgio/gotils v0.0.0-20250924091648-bce9a52d7761 h1:McifyVxygw1d67y6vxUqls2D46J8W9nrki9c8c0eVvE=
-github.com/savsgio/gotils v0.0.0-20250924091648-bce9a52d7761/go.mod h1:Vi9gvHvTw4yCUHIznFl5TPULS7aXwgaTByGeBY75Wko=
-github.com/sony/gobreaker v1.0.0 h1:feX5fGGXSl3dYd4aHZItw+FpHLvvoaqkawKjVNiFMNQ=
-github.com/sony/gobreaker v1.0.0/go.mod h1:ZKptC7FHNvhBz7dN2LGjPVBz2sZJmc0/PkyDJOjmxWY=
+github.com/redis/go-redis/v9 v9.7.0 h1:HhLSs+B6O021gwzl+locl0zEDnyNkxMtf/Z3NNBMa9E=
+github.com/redis/go-redis/v9 v9.7.0/go.mod h1:f6zhXITC7JUJIlPEiBOTXxJgPLdZcA93GewI7inzyWw=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/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.68.0 h1:v12Nx16iepr8r9ySOwqI+5RBJ/DqTxhOy1HrHoDFnok=
-github.com/valyala/fasthttp v1.68.0/go.mod h1:5EXiRfYQAoiO/khu4oU9VISC/eVY6JqmSpPJoHCKsz4=
+github.com/valyala/fasthttp v1.58.0 h1:GGB2dWxSbEprU9j0iMJHgdKYJVDyjrOwF9RE59PbRuE=
+github.com/valyala/fasthttp v1.58.0/go.mod h1:SYXvHHaFp7QZHGKSHmoMipInhrI5StHrhDTYVEjK/Kw=
 github.com/valyala/fastrand v1.1.0 h1:f+5HkLW4rsgzdNoleUOB69hyT9IlD2ZQh9GyDMfb5G8=
 github.com/valyala/fastrand v1.1.0/go.mod h1:HWqCzkrkg6QXT8V2EXWvXCoow7vLwOFN002oeRzjapQ=
 github.com/valyala/histogram v1.2.0 h1:wyYGAZZt3CpwUiIb9AU/Zbllg1llXyrtApRS815OLoQ=
 github.com/valyala/histogram v1.2.0/go.mod h1:Hb4kBwb4UxsaNbbbh+RRz8ZR6pdodR57tzWUS3BUzXY=
+github.com/valyala/tcplisten v1.0.0 h1:rBHj/Xf+E1tRGZyWIWwJDiRY0zc1Js+CV5DqwacVSA8=
+github.com/valyala/tcplisten v1.0.0/go.mod h1:T0xQ8SeCZGxckz9qRXTfG43PvQ/mcWh7FwZEA7Ioqkc=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e h1:JVG44RsyaB9T2KIHavMF/ppJZNG9ZpyihvCd0w101no=
+github.com/xo/terminfo v0.0.0-20220910002029-abceb7e1c41e/go.mod h1:RbqR21r5mrJuqunuUZ/Dhy/avygyECGrLceyNeo4LiM=
 github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
 github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 github.com/yuin/gopher-lua v1.1.1 h1:kYKnWBjvbNP4XLT3+bPEwAXJx262OhaHDWDVOPjL46M=
 github.com/yuin/gopher-lua v1.1.1/go.mod h1:GBR0iDaNXjAgGg9zfCvksxSRnQx76gclCIb7kdAd1Pw=
-go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
-go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
-go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
-go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 h1:lwI4Dc5leUqENgGuQImwLo4WnuXFPetmPpkLi2IrX54=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0/go.mod h1:Kz/oCE7z5wuyhPxsXDuaPteSWqjSBD5YaSdbxZYGbGk=
-go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
-go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
-go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
-go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
-go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
-go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
-go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
-go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
-go.opentelemetry.io/proto/otlp v1.9.0 h1:l706jCMITVouPOqEnii2fIAuO3IVGBRPV5ICjceRb/A=
-go.opentelemetry.io/proto/otlp v1.9.0/go.mod h1:xE+Cx5E/eEHw+ISFkwPLwCZefwVjY+pqKg1qcK03+/4=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/otel v1.34.0 h1:zRLXxLCgL1WyKsPVrgbSdMN4c0FMkDAskSTQP+0hdUY=
+go.opentelemetry.io/otel v1.34.0/go.mod h1:OWFPOQ+h4G8xpyjgqo4SxJYdDQ/qmRH+wivy7zzx9oI=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.34.0 h1:OeNbIYk/2C15ckl7glBlOBp5+WlYsOElzTNmiPW/x60=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.34.0/go.mod h1:7Bept48yIeqxP2OZ9/AqIpYS94h2or0aB4FypJTc8ZM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.34.0 h1:tgJ0uaNS4c98WRNUEx5U3aDlrDOI5Rs+1Vifcw4DJ8U=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.34.0/go.mod h1:U7HYyW0zt/a9x5J1Kjs+r1f/d4ZHnYFclhYY2+YbeoE=
+go.opentelemetry.io/otel/metric v1.34.0 h1:+eTR3U0MyfWjRDhmFMxe2SsW64QrZ84AOhvqS7Y+PoQ=
+go.opentelemetry.io/otel/metric v1.34.0/go.mod h1:CEDrp0fy2D0MvkXE+dPV7cMi8tWZwX3dmaIhwPOaqHE=
+go.opentelemetry.io/otel/sdk v1.34.0 h1:95zS4k/2GOy069d321O8jWgYsW3MzVV+KuSPKp7Wr1A=
+go.opentelemetry.io/otel/sdk v1.34.0/go.mod h1:0e/pNiaMAqaykJGKbi+tSjWfNNHMTxoC9qANsCzbyxU=
+go.opentelemetry.io/otel/sdk/metric v1.32.0 h1:rZvFnvmvawYb0alrYkjraqJq0Z4ZUJAiyYCU9snn1CU=
+go.opentelemetry.io/otel/sdk/metric v1.32.0/go.mod h1:PWeZlq0zt9YkYAp3gjKZ0eicRYvOh1Gd+X99x6GHpCQ=
+go.opentelemetry.io/otel/trace v1.34.0 h1:+ouXS2V8Rd4hp4580a8q23bg0azF2nI8cqLYnC8mh/k=
+go.opentelemetry.io/otel/trace v1.34.0/go.mod h1:Svm7lSjQD7kG7KJ/MUHPVXSDGz2OX4h0M2jHBhmSfRE=
+go.opentelemetry.io/proto/otlp v1.5.0 h1:xJvq7gMzB31/d406fB8U5CBdyQGw4P399D1aQWU/3i4=
+go.opentelemetry.io/proto/otlp v1.5.0/go.mod h1:keN8WnHxOy8PG0rQZjJJ5A2ebUoafqWp0eVQ4yIXvJ4=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
-golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
-golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
-golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
-golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
-golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561 h1:MDc5xs78ZrZr3HMQugiXOAkSZtfTpbJLDr/lwfgO53E=
+golang.org/x/exp v0.0.0-20220909182711-5c715a9e8561/go.mod h1:cyybsKvd6eL0RnXn6p/Grxp8F5bW7iYuBgsNCOHpMYE=
+golang.org/x/net v0.34.0 h1:Mb7Mrk043xzHgnRM88suvJFwzVrRfHEHJEl5/71CKw0=
+golang.org/x/net v0.34.0/go.mod h1:di0qlW3YNM5oh6GqDGQr92MyTozJPmybPK4Ev/Gm31k=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
-golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
-golang.org/x/term v0.37.0 h1:8EGAD0qCmHYZg6J17DvsMy9/wJ7/D/4pV/wfnld5lTU=
-golang.org/x/term v0.37.0/go.mod h1:5pB4lxRNYYVZuTLmy8oR2BH8dflOR+IbTYFD8fi3254=
-golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
-golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
-gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
-gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
-google.golang.org/genproto/googleapis/api v0.0.0-20251202230838-ff82c1b0f217 h1:fCvbg86sFXwdrl5LgVcTEvNC+2txB5mgROGmRL5mrls=
-google.golang.org/genproto/googleapis/api v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:+rXWjjaukWZun3mLfjmVnQi18E1AsFbDN9QdJ5YXLto=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217 h1:gRkg/vSppuSQoDjxyiGfN4Upv/h/DQmIR10ZU8dh4Ww=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20251202230838-ff82c1b0f217/go.mod h1:7i2o+ce6H/6BluujYR+kqX3GKH+dChPTQU19wjRPiGk=
-google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM=
-google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig=
-google.golang.org/protobuf v1.36.10 h1:AYd7cD/uASjIL6Q9LiTjz8JLcrh/88q5UObnmY3aOOE=
-google.golang.org/protobuf v1.36.10/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250204164813-702378808489 h1:fCuMM4fowGzigT89NCIsW57Pk9k2D12MMi2ODn+Nk+o=
+google.golang.org/genproto/googleapis/api v0.0.0-20250204164813-702378808489/go.mod h1:iYONQfRdizDB8JJBybql13nArx91jcUk7zCXEsOofM4=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489 h1:5bKytslY8ViY0Cj/ewmRtrWHW64bNF03cAatUUFCdFI=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250204164813-702378808489/go.mod h1:8BS3B93F/U1juMFq9+EDk+qOT5CO1R9IzXxG3PTqiRk=
+google.golang.org/grpc v1.70.0 h1:pWFv03aZoHzlRKHWicjsZytKAiYCtNS0dHbXnIdq7jQ=
+google.golang.org/grpc v1.70.0/go.mod h1:ofIJqVKDXx/JiXrwr2IG4/zwdH9txy3IlF40RmcJSQw=
+google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
+google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=

graphql.go

@@ -1,19 +1,14 @@
 package main
 
 import (
-	"runtime"
 	"strconv"
 	"strings"
 	"sync"
-	"sync/atomic"
-	"time"
-	"unicode"
 
 	"github.com/goccy/go-json"
 	fiber "github.com/gofiber/fiber/v2"
 	"github.com/graphql-go/graphql/language/ast"
 	"github.com/graphql-go/graphql/language/parser"
-	"github.com/graphql-go/graphql/language/source"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 )
@@ -29,49 +24,8 @@ var (
 	}
 	introspectionAllowedQueries = make(map[string]struct{})
 	allowedUrls                 = make(map[string]struct{})
-
-	// Cache for parsed GraphQL queries to avoid reparsing
-	parsedQueryCache *LRUCache
-
-	// Maximum size for parsed query cache
-	maxQueryCacheSize = 1000
-	currentCacheSize  int64 // Use atomic operations for this
 )
 
-// sanitizeOperationName removes null bytes and other invalid characters from operation names
-// This prevents panics when creating metrics with invalid label values
-func sanitizeOperationName(name string) string {
-	if name == "" || name == "undefined" {
-		return name
-	}
-
-	var buf strings.Builder
-	buf.Grow(len(name))
-
-	for _, r := range name {
-		// Skip null bytes entirely
-		if r == '\x00' {
-			continue
-		}
-		// Replace control characters with underscores
-		if r < 32 || r == 127 {
-			buf.WriteByte('_')
-			continue
-		}
-		// Only allow printable characters
-		if unicode.IsPrint(r) {
-			buf.WriteRune(r)
-		}
-	}
-
-	result := buf.String()
-	// Return "undefined" if we ended up with an empty string after sanitization
-	if result == "" {
-		return "undefined"
-	}
-	return result
-}
-
 func prepareQueriesAndExemptions() {
 	introspectionAllowedQueries = make(map[string]struct{})
 	allowedUrls = make(map[string]struct{})
@@ -99,424 +53,172 @@ type parseGraphQLQueryResult struct {
 	shouldIgnore   bool
 }
 
-// AST node pools to reduce GC pressure
 var (
-	// Pool for request/response maps during unmarshaling
 	queryPool = sync.Pool{
 		New: func() interface{} {
 			return make(map[string]interface{}, 48)
 		},
 	}
-
-	// Pool for parse result objects
 	resultPool = sync.Pool{
 		New: func() interface{} {
 			return &parseGraphQLQueryResult{}
 		},
 	}
-
-	// Mutex for allocation tracking
-	allocsMutex = sync.Mutex{}
 )
 
-// The following variables are reserved for future GraphQL parsing optimization
-// and are not currently in use:
-// - fieldPool (Field object pool)
-// - operationPool (OperationDefinition object pool)
-// - namePool (Name object pool)
-// - documentPool (Document object pool)
-// - allocsCounter (for tracking allocation counts)
-// - allocationsSamp (for memory usage histograms)
-
-// Initialize the query parse cache with configurable size
-func initGraphQLParsing() {
-	// Use configured cache size, or default to CPU-based calculation
-	var cacheSize int
-	if cfg != nil && cfg.Cache.GraphQLQueryCacheSize > 0 {
-		cacheSize = cfg.Cache.GraphQLQueryCacheSize
-	} else {
-		// Fallback to CPU-based calculation
-		cacheSize = runtime.GOMAXPROCS(0) * 250
-	}
-	maxQueryCacheSize = cacheSize
-
-	// Initialize LRU cache with entry limit and 50MB size limit
-	parsedQueryCache = NewLRUCache(maxQueryCacheSize, 50*1024*1024)
-
-	if cfg != nil && cfg.Logger != nil {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "GraphQL query cache initialized",
-			Pairs: map[string]interface{}{
-				"max_entries": maxQueryCacheSize,
-				"max_size_mb": 50,
-			},
-		})
-	}
-}
-
-// Store a parsed document in the cache with LRU eviction
-func cacheQuery(queryText string, document *ast.Document) {
-	if parsedQueryCache == nil {
-		return
-	}
-
-	// Store the document in the cache with timestamp for LRU
-	cacheEntry := &CachedQuery{
-		Document:  document,
-		Timestamp: time.Now(),
-	}
-
-	// The LRU cache handles eviction automatically
-	parsedQueryCache.Set(queryText, cacheEntry, int64(len(queryText)))
-	atomic.AddInt64(&currentCacheSize, 1)
-}
-
-// CachedQuery represents a cached GraphQL query with timestamp for LRU
-type CachedQuery struct {
-	Document  *ast.Document
-	Timestamp time.Time
-}
-
-// evictOldestQueries is no longer needed with LRU cache
-// The LRU cache handles eviction automatically
-
-// Check if we have a cached parsed query
-func getCachedQuery(queryText string) *ast.Document {
-	if parsedQueryCache == nil {
-		return nil
-	}
-
-	if entry, found := parsedQueryCache.Get(queryText); found {
-		if cachedQuery, ok := entry.(*CachedQuery); ok {
-			if cfg != nil && cfg.Monitoring != nil {
-				cfg.Monitoring.Increment(libpack_monitoring.MetricsGraphQLCacheHit, nil)
-			}
-			return cachedQuery.Document
-		}
-	}
-
-	if cfg != nil && cfg.Monitoring != nil {
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsGraphQLCacheMiss, nil)
-	}
-	return nil
-}
-
-// Track and report memory allocations for GraphQL parsing
-func trackParsingAllocations() func() {
-	var m1 runtime.MemStats
-	runtime.ReadMemStats(&m1)
-
-	return func() {
-		var m2 runtime.MemStats
-		runtime.ReadMemStats(&m2)
-
-		// Calculate allocations
-		allocsMutex.Lock()
-		allocsDelta := int(m2.Mallocs - m1.Mallocs)
-		// Note: allocsCounter variable is currently unused but will be used in future
-		// allocsCounter += allocsDelta
-		allocsMutex.Unlock()
-
-		// Record allocation count metrics
-		if cfg != nil && cfg.Monitoring != nil {
-			cfg.Monitoring.IncrementFloat(libpack_monitoring.MetricsGraphQLParsingAllocs, nil, float64(allocsDelta))
-		}
-	}
-}
-
 func parseGraphQLQuery(c *fiber.Ctx) *parseGraphQLQueryResult {
-	startTime := time.Now()
-
-	// Set up allocation tracking
-	trackAllocs := trackParsingAllocations()
-	defer trackAllocs()
-
-	// Get a result object from the pool and initialize it
 	res := resultPool.Get().(*parseGraphQLQueryResult)
-	*res = parseGraphQLQueryResult{shouldIgnore: true}
+	*res = parseGraphQLQueryResult{shouldIgnore: true, activeEndpoint: cfg.Server.HostGraphQL}
 
-	// Ensure we return the result to the pool on function exit
-	defer func() {
-		resultPool.Put(res)
-	}()
-
-	// Default to using the write endpoint
-	res.activeEndpoint = cfg.Server.HostGraphQL
-
-	// Get a map from the pool for JSON unmarshaling
 	m := queryPool.Get().(map[string]interface{})
 	defer func() {
-		// Clear and return the map to the pool
 		for k := range m {
 			delete(m, k)
 		}
 		queryPool.Put(m)
 	}()
 
-	// Add comprehensive input validation
-	bodySize := len(c.Body())
-
-	// Validate query size to prevent DoS attacks
-	if bodySize > 1024*1024 { // 1MB limit
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-		}
-		return res
-	}
-
-	// Validate minimum size
-	if bodySize < 2 { // At least "{}"
-		if ifNotInTest() {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
-		}
-		return res
-	}
-
-	// Unmarshal the request body
 	if err := json.Unmarshal(c.Body(), &m); err != nil {
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't unmarshal the request",
+			Pairs:   map[string]interface{}{"error": err.Error(), "body": string(c.Body())},
+		})
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 		}
 		return res
 	}
 
-	// Extract the query string
 	query, ok := m["query"].(string)
 	if !ok {
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't find the query",
+			Pairs:   map[string]interface{}{"m_val": m},
+		})
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 		}
 		return res
 	}
 
-	// Try to get the query from cache first
-	var p *ast.Document
-	cachedDoc := getCachedQuery(query)
-
-	if cachedDoc != nil {
-		// Use the cached document
-		p = cachedDoc
-	} else {
-		// Parse the GraphQL query with improved source handling
-		src := source.NewSource(&source.Source{
-			Body: []byte(query),
-			Name: "GraphQL request",
+	p, err := parser.Parse(parser.ParseParams{Source: query})
+	if err != nil {
+		cfg.Logger.Error(&libpack_logger.LogMessage{
+			Message: "Can't parse the query",
+			Pairs:   map[string]interface{}{"query": query, "m_val": m},
 		})
-
-		var err error
-		p, err = parser.Parse(parser.ParseParams{Source: src})
-		if err != nil {
-			if ifNotInTest() {
-				cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-				cfg.Monitoring.Increment(libpack_monitoring.MetricsGraphQLParsingErrors, nil)
-			}
-			return res
+		if ifNotInTest() {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
 		}
-
-		// Cache the successful parse result for future use
-		cacheQuery(query, p)
+		return res
 	}
 
-	// Mark as a valid GraphQL query
 	res.shouldIgnore = false
 	res.operationName = "undefined"
 
-	// First scan for mutations - they take priority
-	hasMutation := false
-	var mutationName string
-
 	for _, d := range p.Definitions {
 		if oper, ok := d.(*ast.OperationDefinition); ok {
-			operationType := strings.ToLower(oper.Operation)
-			if operationType == "mutation" {
-				hasMutation = true
-				res.operationType = "mutation"
+			if res.operationType == "" {
+				res.operationType = strings.ToLower(oper.Operation)
 				if oper.Name != nil {
-					mutationName = oper.Name.Value
-					// Use mutation name immediately, sanitized to prevent metric panics
-					res.operationName = sanitizeOperationName(mutationName)
-				}
-				break // Found a mutation, no need to continue first pass
-			}
-		}
-	}
-
-	// Now process all definitions for other information
-	for _, d := range p.Definitions {
-		if oper, ok := d.(*ast.OperationDefinition); ok {
-			operationType := strings.ToLower(oper.Operation)
-
-			// If we already found a mutation, only update name if needed
-			if hasMutation {
-				// We already set operation type to mutation in first pass
-				// Only set name if we didn't find a mutation name earlier
-				if res.operationName == "undefined" && oper.Name != nil {
-					res.operationName = sanitizeOperationName(oper.Name.Value)
-				}
-			} else {
-				// No mutation found, use the normal logic
-				if res.operationType == "" {
-					res.operationType = operationType
-				}
-
-				if res.operationName == "undefined" && oper.Name != nil {
-					res.operationName = sanitizeOperationName(oper.Name.Value)
+					res.operationName = oper.Name.Value
+				}
+			}
+
+			if cfg.Server.HostGraphQLReadOnly != "" {
+				if res.operationType == "" || res.operationType != "mutation" {
+					res.activeEndpoint = cfg.Server.HostGraphQLReadOnly
 				}
 			}
 
-			// Block mutations in read-only mode
 			if res.operationType == "mutation" && cfg.Server.ReadOnlyMode {
+				cfg.Logger.Warning(&libpack_logger.LogMessage{
+					Message: "Mutation blocked - server in read-only mode",
+					Pairs:   map[string]interface{}{"query": query},
+				})
 				if ifNotInTest() {
 					cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 				}
 				_ = c.Status(403).SendString("The server is in read-only mode")
 				res.shouldBlock = true
+				resultPool.Put(res)
 				return res
 			}
 
-			// Process directives (like @cached)
-			processDirectives(oper, res)
-
-			// Check for introspection queries if they're blocked
-			if cfg.Security.BlockIntrospection && checkSelections(c, oper.GetSelectionSet().Selections) {
-				_ = c.Status(403).SendString("Introspection queries are not allowed")
-				res.shouldBlock = true
-				return res
+			for _, dir := range oper.Directives {
+				if dir.Name.Value == "cached" {
+					res.cacheRequest = true
+					for _, arg := range dir.Arguments {
+						switch arg.Name.Value {
+						case "ttl":
+							if v, ok := arg.Value.GetValue().(string); ok {
+								res.cacheTime, _ = strconv.Atoi(v)
+							}
+						case "refresh":
+							if v, ok := arg.Value.GetValue().(bool); ok {
+								res.cacheRefresh = v
+							}
+						}
+					}
+				}
 			}
-		}
-	}
 
-	// Handle endpoint routing AFTER processing all definitions
-	// This ensures mutations are always routed to the write endpoint
-	if res.operationType == "mutation" {
-		res.activeEndpoint = cfg.Server.HostGraphQL
-	} else if cfg.Server.HostGraphQLReadOnly != "" {
-		// Use read-only endpoint for non-mutation operations
-		res.activeEndpoint = cfg.Server.HostGraphQLReadOnly
-	}
-
-	// Track parsing time
-	if ifNotInTest() && cfg.Monitoring != nil {
-		parseTime := float64(time.Since(startTime).Milliseconds())
-		cfg.Monitoring.IncrementFloat(libpack_monitoring.MetricsGraphQLParsingTime, nil, parseTime)
-	}
-
-	// Create a copy to return, since the original will be returned to the pool
-	// This prevents race conditions where concurrent requests could modify the same result
-	result := *res
-	return &result
-}
-
-// processDirectives extracts caching directives from the operation
-func processDirectives(oper *ast.OperationDefinition, res *parseGraphQLQueryResult) {
-	for _, dir := range oper.Directives {
-		if dir.Name.Value == "cached" {
-			res.cacheRequest = true
-			for _, arg := range dir.Arguments {
-				switch arg.Name.Value {
-				case "ttl":
-					if v, ok := arg.Value.GetValue().(string); ok {
-						res.cacheTime, _ = strconv.Atoi(v)
-					}
-				case "refresh":
-					if v, ok := arg.Value.GetValue().(bool); ok {
-						res.cacheRefresh = v
-					}
+			if cfg.Security.BlockIntrospection {
+				if checkSelections(c, oper.GetSelectionSet().Selections) {
+					_ = c.Status(403).SendString("Introspection queries are not allowed")
+					res.shouldBlock = true
+					resultPool.Put(res)
+					return res
 				}
 			}
 		}
 	}
+	return res
 }
 
-// checkSelections recursively checks if any selection is an introspection query that should be blocked
 func checkSelections(c *fiber.Ctx, selections []ast.Selection) bool {
-	if len(selections) == 0 {
-		return false
-	}
-
-	// Fast path: if no introspection blocking is configured, return immediately
-	if !cfg.Security.BlockIntrospection {
-		return false
-	}
-
-	// Fast path: if there are no allowed introspection queries, check only top level
-	hasAllowList := len(cfg.Security.IntrospectionAllowed) > 0
-
 	for _, s := range selections {
 		switch sel := s.(type) {
 		case *ast.Field:
 			fieldName := strings.ToLower(sel.Name.Value)
-
-			// Check if this is an introspection query
 			if _, exists := introspectionQueries[fieldName]; exists {
-				if hasAllowList {
-					// Check if it's in the allowed list
-					if _, allowed := introspectionAllowedQueries[fieldName]; !allowed {
-						return true // Block if not allowed
+				if len(cfg.Security.IntrospectionAllowed) > 0 {
+					_, allowed := introspectionAllowedQueries[fieldName]
+					if !allowed {
+						return true // Block if this field isn't allowed
 					}
+					// Even if this field is allowed, we need to check its nested selections
 				} else {
 					return true // Block if no allowlist exists
 				}
 			}
-
-			// Check nested selections if present
-			if sel.SelectionSet != nil && len(sel.GetSelectionSet().Selections) > 0 {
+			// Always check nested selections
+			if sel.SelectionSet != nil {
 				if checkSelections(c, sel.GetSelectionSet().Selections) {
 					return true
 				}
 			}
-
 		case *ast.InlineFragment:
-			// Check nested selections in fragments
-			if sel.SelectionSet != nil && len(sel.GetSelectionSet().Selections) > 0 {
+			if sel.SelectionSet != nil {
 				if checkSelections(c, sel.GetSelectionSet().Selections) {
 					return true
 				}
 			}
 		}
 	}
-
 	return false
 }
 
 func checkIfContainsIntrospection(c *fiber.Ctx, query string) bool {
-	startTime := time.Now()
 	blocked := false
-
-	// Enable introspection blocking for tests
-	if !cfg.Security.BlockIntrospection {
-		cfg.Security.BlockIntrospection = true
-	}
-
-	// Try to get cached parse result first
-	var p *ast.Document
-	cachedDoc := getCachedQuery(query)
-
-	if cachedDoc != nil {
-		p = cachedDoc
-	} else {
-		// Try parsing as a complete query
-		src := source.NewSource(&source.Source{
-			Body: []byte(query),
-			Name: "GraphQL introspection check",
-		})
-
-		var err error
-		p, err = parser.Parse(parser.ParseParams{Source: src})
-
-		if err == nil && p != nil {
-			// Cache the successful parse
-			cacheQuery(query, p)
-		}
-	}
-
-	if p != nil {
+	// Try parsing as a complete query first
+	p, err := parser.Parse(parser.ParseParams{Source: query})
+	if err == nil {
 		// It's a complete query, check all selections
 		for _, def := range p.Definitions {
 			if op, ok := def.(*ast.OperationDefinition); ok {
 				if op.SelectionSet != nil {
 					blocked = checkSelections(c, op.GetSelectionSet().Selections)
-					break
 				}
 			}
 		}
@@ -540,15 +242,5 @@ func checkIfContainsIntrospection(c *fiber.Ctx, query string) bool {
 		}
 		_ = c.Status(403).SendString("Introspection queries are not allowed")
 	}
-
-	// Track parsing time
-	if ifNotInTest() && cfg.Monitoring != nil {
-		parseTime := float64(time.Since(startTime).Milliseconds())
-		cfg.Monitoring.IncrementFloat(libpack_monitoring.MetricsGraphQLParsingTime, nil, parseTime)
-	}
-
 	return blocked
 }
-
-// NOTE: The clearQueryCache function has been removed as it was unused.
-// This functionality will be exposed through an API endpoint in a future release.

graphql_test.go

@@ -13,6 +13,7 @@ import (
 )
 
 func (suite *Tests) Test_parseGraphQLQuery() {
+
 	type results struct {
 		op_name      string
 		op_type      string
@@ -281,19 +282,15 @@ func (suite *Tests) Test_parseGraphQLQuery() {
 		suite.Run(tt.name, func() {
 			cfg = &config{}
 			parseConfig()
-			// Create a context first, then modify its request directly
-			reqCtx := &fasthttp.RequestCtx{}
-
-			// Set headers directly on the request
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
+			
+			// Set headers
 			for k, v := range tt.suppliedQuery.headers {
-				reqCtx.Request.Header.Add(k, v)
+				ctx.Request().Header.Add(k, v)
 			}
 
-			// Set the body
-			reqCtx.Request.AppendBody([]byte(tt.suppliedQuery.body))
-
-			// Now create the fiber context with the request context
-			ctx := suite.app.AcquireCtx(reqCtx)
+			// Set body
+			ctx.Request().AppendBody([]byte(tt.suppliedQuery.body))
 
 			// defer func() {
 			// 	cfg = &config{}
@@ -301,22 +298,22 @@ func (suite *Tests) Test_parseGraphQLQuery() {
 			// 	suite.app.ReleaseCtx(ctx)
 			// }()
 
-			suite.NotNil(ctx, "Fiber context is nil")
+			assert.NotNil(ctx, "Fiber context is nil")
 
 			if tt.suppliedSettings != nil {
 				cfg = tt.suppliedSettings
 			}
 			prepareQueriesAndExemptions()
 			parseResult := parseGraphQLQuery(ctx)
-			suite.Equal(tt.wantResults.op_type, parseResult.operationType, "Unexpected operation type "+tt.name)
-			suite.Equal(tt.wantResults.op_name, parseResult.operationName, "Unexpected operation name "+tt.name)
-			suite.Equal(tt.wantResults.is_cached, parseResult.cacheRequest, "Unexpected cache value "+tt.name)
-			suite.Equal(tt.wantResults.cached_ttl, parseResult.cacheTime, "Unexpected cache TTL value "+tt.name)
-			suite.Equal(tt.wantResults.shouldBlock, parseResult.shouldBlock, "Unexpected block value "+tt.name)
-			suite.Equal(tt.wantResults.shouldIgnore, parseResult.shouldIgnore, "Unexpected ignore value "+tt.name)
+			assert.Equal(tt.wantResults.op_type, parseResult.operationType, "Unexpected operation type "+tt.name)
+			assert.Equal(tt.wantResults.op_name, parseResult.operationName, "Unexpected operation name "+tt.name)
+			assert.Equal(tt.wantResults.is_cached, parseResult.cacheRequest, "Unexpected cache value "+tt.name)
+			assert.Equal(tt.wantResults.cached_ttl, parseResult.cacheTime, "Unexpected cache TTL value "+tt.name)
+			assert.Equal(tt.wantResults.shouldBlock, parseResult.shouldBlock, "Unexpected block value "+tt.name)
+			assert.Equal(tt.wantResults.shouldIgnore, parseResult.shouldIgnore, "Unexpected ignore value "+tt.name)
 
 			if tt.wantResults.returnCode > 0 {
-				suite.Equal(tt.wantResults.returnCode, ctx.Response().StatusCode(), "Unexpected return code", tt.name)
+				assert.Equal(tt.wantResults.returnCode, ctx.Response().StatusCode(), "Unexpected return code", tt.name)
 			}
 		})
 	}
@@ -344,10 +341,9 @@ func (suite *Tests) Test_parseGraphQLQuery_complex() {
 		body := fmt.Sprintf(`{"query": %q}`, query)
 		ctx := createTestContext(body)
 		result := parseGraphQLQuery(ctx)
-		// Since we now prioritize mutations when present in a GraphQL document with multiple operations
-		suite.Equal("mutation", result.operationType)
-		suite.Equal("UpdateUser", result.operationName)
-		suite.False(result.shouldBlock)
+		assert.Equal("query", result.operationType)
+		assert.Equal("GetUser", result.operationName)
+		assert.False(result.shouldBlock)
 	})
 
 	suite.Run("test query with custom directives", func() {
@@ -362,10 +358,10 @@ func (suite *Tests) Test_parseGraphQLQuery_complex() {
 		body := fmt.Sprintf(`{"query": %q}`, query)
 		ctx := createTestContext(body)
 		result := parseGraphQLQuery(ctx)
-		suite.Equal("query", result.operationType)
-		suite.Equal("GetUser", result.operationName)
-		suite.False(result.shouldBlock)
-		suite.False(result.shouldBlock)
+		assert.Equal("query", result.operationType)
+		assert.Equal("GetUser", result.operationName)
+		assert.False(result.shouldBlock)
+		assert.False(result.shouldBlock)
 	})
 }
 
@@ -393,7 +389,7 @@ func (suite *Tests) Test_checkAllowedURLs() {
 			ctx.Request().SetRequestURI(tt.path)
 			ctx.Request().URI().SetPath(tt.path)
 			result := checkAllowedURLs(ctx)
-			suite.Equal(tt.expected, result, "Unexpected result in test case: "+tt.name)
+			assert.Equal(tt.expected, result, "Unexpected result in test case: "+tt.name)
 		})
 	}
 }
@@ -421,7 +417,7 @@ func (suite *Tests) Test_checkIfContainsIntrospection() {
 			}
 			ctx := createTestContext("")
 			result := checkIfContainsIntrospection(ctx, tt.query)
-			suite.Equal(tt.expected, result)
+			assert.Equal(tt.expected, result)
 		})
 	}
 }
@@ -505,9 +501,9 @@ func (suite *Tests) Test_DeepIntrospectionQueries() {
 func TestIntrospectionQueryHandling(t *testing.T) {
 	tests := []struct {
 		name               string
-		query              string
-		allowedQueries     []string
 		blockIntrospection bool
+		allowedQueries     []string
+		query              string
 		wantBlocked        bool
 	}{
 		{

gzip_error_handling_test.go

@@ -1,345 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	"github.com/valyala/fasthttp"
-)
-
-// Tests for error handling in gzip decompression and general error propagation
-
-// TestGzipHandling tests proper handling of gzipped responses
-func (suite *Tests) TestGzipHandling() {
-	// Create a test server that returns gzipped content
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Set the Content-Encoding header to indicate gzipped content
-		w.Header().Set("Content-Encoding", "gzip")
-
-		// Create a gzipped response
-		var buf bytes.Buffer
-		gzipWriter := gzip.NewWriter(&buf)
-		payload := `{"data":{"test":"gzipped response"}}`
-		_, _ = gzipWriter.Write([]byte(payload))
-		_ = gzipWriter.Close()
-
-		// Send the gzipped data
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write(buf.Bytes())
-	}))
-	defer server.Close()
-
-	// Store original client and restore after test
-	originalClient := cfg.Client.FastProxyClient
-	defer func() {
-		cfg.Client.FastProxyClient = originalClient
-	}()
-
-	// Configure client for test
-	cfg.Client.ClientTimeout = 5
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-	// Configure server URL
-	cfg.Server.HostGraphQL = server.URL
-
-	// Create request context
-	reqCtx := &fasthttp.RequestCtx{}
-	reqCtx.Request.SetRequestURI("/graphql")
-	reqCtx.Request.Header.SetMethod("POST")
-	reqCtx.Request.Header.Set("Content-Type", "application/json")
-	reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-	// Create fiber context
-	ctx := suite.app.AcquireCtx(reqCtx)
-	defer suite.app.ReleaseCtx(ctx)
-
-	// Call the proxy function
-	err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-	// Verify success
-	suite.Nil(err, "proxyTheRequest should succeed with gzipped content")
-	suite.Equal(fiber.StatusOK, ctx.Response().StatusCode(), "Response status should be 200 OK")
-
-	// Verify the content was properly decompressed
-	responseBody := string(ctx.Response().Body())
-	suite.Contains(responseBody, "gzipped response", "Response should contain the decompressed content")
-
-	// Verify the Content-Encoding header was removed
-	suite.Equal("", string(ctx.Response().Header.Peek("Content-Encoding")),
-		"Content-Encoding header should be removed after decompression")
-}
-
-// TestInvalidGzipHandling tests handling of responses with invalid gzip data
-func (suite *Tests) TestInvalidGzipHandling() {
-	// Create a test server that returns invalid gzipped content
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Set the Content-Encoding header to indicate gzipped content
-		w.Header().Set("Content-Encoding", "gzip")
-
-		// Send invalid gzip data
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte("This is not valid gzip data"))
-	}))
-	defer server.Close()
-
-	// Store original client and restore after test
-	originalClient := cfg.Client.FastProxyClient
-	defer func() {
-		cfg.Client.FastProxyClient = originalClient
-	}()
-
-	// Configure client for test
-	cfg.Client.ClientTimeout = 5
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-	// Configure server URL
-	cfg.Server.HostGraphQL = server.URL
-
-	// Create request context
-	reqCtx := &fasthttp.RequestCtx{}
-	reqCtx.Request.SetRequestURI("/graphql")
-	reqCtx.Request.Header.SetMethod("POST")
-	reqCtx.Request.Header.Set("Content-Type", "application/json")
-	reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-	// Create fiber context
-	ctx := suite.app.AcquireCtx(reqCtx)
-	defer suite.app.ReleaseCtx(ctx)
-
-	// Call the proxy function
-	err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-	// Verify error handling
-	suite.NotNil(err, "proxyTheRequest should return error with invalid gzip data")
-	suite.Contains(err.Error(), "gzip", "Error should mention gzip decompression issue")
-}
-
-// TestErrorPropagation tests that various errors are properly propagated
-func (suite *Tests) TestErrorPropagation() {
-	tests := []struct {
-		name          string
-		serverHandler func(w http.ResponseWriter, r *http.Request)
-		expectedError string
-	}{
-		{
-			name: "5xx_error",
-			serverHandler: func(w http.ResponseWriter, r *http.Request) {
-				w.WriteHeader(http.StatusInternalServerError)
-				_, _ = w.Write([]byte(`{"errors":[{"message":"Internal server error"}]}`))
-			},
-			expectedError: "received non-200 response",
-		},
-		{
-			name: "malformed_json_response",
-			serverHandler: func(w http.ResponseWriter, r *http.Request) {
-				w.WriteHeader(http.StatusOK)
-				_, _ = w.Write([]byte(`{malformed json`))
-			},
-			expectedError: "", // No error expected, as we don't validate JSON format
-		},
-		{
-			name: "empty_response",
-			serverHandler: func(w http.ResponseWriter, r *http.Request) {
-				w.WriteHeader(http.StatusOK)
-				// Empty response body
-			},
-			expectedError: "", // No error expected, empty responses are valid
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			// Create a test server with the current test handler
-			server := httptest.NewServer(http.HandlerFunc(tt.serverHandler))
-			defer server.Close()
-
-			// Store original client and restore after test
-			originalClient := cfg.Client.FastProxyClient
-			defer func() {
-				cfg.Client.FastProxyClient = originalClient
-			}()
-
-			// Configure client for test
-			cfg.Client.ClientTimeout = 5
-			cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-			// Configure server URL
-			cfg.Server.HostGraphQL = server.URL
-
-			// Create request context
-			reqCtx := &fasthttp.RequestCtx{}
-			reqCtx.Request.SetRequestURI("/graphql")
-			reqCtx.Request.Header.SetMethod("POST")
-			reqCtx.Request.Header.Set("Content-Type", "application/json")
-			reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-			// Create fiber context
-			ctx := suite.app.AcquireCtx(reqCtx)
-			defer suite.app.ReleaseCtx(ctx)
-
-			// Call the proxy function
-			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-			// Verify error handling based on test case
-			if tt.expectedError != "" {
-				suite.NotNil(err, "proxyTheRequest should return error")
-				suite.Contains(err.Error(), tt.expectedError,
-					"Error should contain expected message")
-			} else {
-				suite.Nil(err, "proxyTheRequest should not return error")
-			}
-		})
-	}
-}
-
-// TestMiddlewareErrorPropagation tests error propagation through the middleware chain
-func (suite *Tests) TestMiddlewareErrorPropagation() {
-	// Setup a basic middleware chain that mimics the production setup
-	testMiddleware := func(c *fiber.Ctx) error {
-		// Access request path to check proper error propagation
-		path := c.Path()
-		if path == "/error-path" {
-			return fmt.Errorf("middleware error")
-		}
-		return c.Next()
-	}
-
-	app := fiber.New()
-	app.Use(testMiddleware)
-
-	// Setup the handler that would receive the request after middleware
-	app.Post("/graphql", func(c *fiber.Ctx) error {
-		// This should not be called if middleware returns error
-		return c.Status(fiber.StatusOK).JSON(fiber.Map{"data": "success"})
-	})
-
-	// Test successful path
-	req := httptest.NewRequest("POST", "/graphql", nil)
-	resp, err := app.Test(req)
-	suite.Nil(err, "App test should not error")
-	suite.Equal(fiber.StatusOK, resp.StatusCode, "Status should be 200 OK")
-
-	// Test error path
-	req = httptest.NewRequest("POST", "/error-path", nil)
-	resp, err = app.Test(req)
-	suite.Nil(err, "App test should not error")
-	suite.NotEqual(fiber.StatusOK, resp.StatusCode, "Status should not be 200 OK")
-
-	// Check that error status was properly propagated
-	suite.Equal(fiber.StatusInternalServerError, resp.StatusCode,
-		"Error status should be 500 Internal Server Error")
-}
-
-// TestTimeout tests the proper handling of timeouts
-func (suite *Tests) TestTimeout() {
-	// Skip this timing-sensitive test as it's prone to race conditions under race detection
-	suite.T().Skip("Skipping timing-sensitive timeout test due to race conditions under race detection")
-
-	// Create a test server that simulates a timeout
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Sleep longer than the client timeout
-		time.Sleep(3 * time.Second)
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"data":{"test":"response"}}`))
-	}))
-	defer server.Close()
-
-	// Store original client and restore after test
-	originalClient := cfg.Client.FastProxyClient
-	originalTimeout := cfg.Client.ClientTimeout
-	defer func() {
-		cfg.Client.FastProxyClient = originalClient
-		cfg.Client.ClientTimeout = originalTimeout
-	}()
-
-	// Configure client with a short timeout
-	cfg.Client.ClientTimeout = 1 // 1 second
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-	// Configure server URL
-	cfg.Server.HostGraphQL = server.URL
-
-	// Create request context
-	reqCtx := &fasthttp.RequestCtx{}
-	reqCtx.Request.SetRequestURI("/graphql")
-	reqCtx.Request.Header.SetMethod("POST")
-	reqCtx.Request.Header.Set("Content-Type", "application/json")
-	reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-	// Create fiber context
-	ctx := suite.app.AcquireCtx(reqCtx)
-	defer suite.app.ReleaseCtx(ctx)
-
-	// Call the proxy function
-	err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-	// Verify timeout error handling
-	suite.NotNil(err, "proxyTheRequest should return error on timeout")
-	if err != nil {
-		suite.Contains(err.Error(), "timeout", "Error should mention timeout")
-	}
-}
-
-// TestLargeResponseHandling tests handling of large responses
-func (suite *Tests) TestLargeResponseHandling() {
-	// Create a test server that returns a large response
-	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Generate a large response (1MB)
-		largeResponse := make([]byte, 1024*1024)
-		for i := 0; i < len(largeResponse); i++ {
-			largeResponse[i] = byte(i % 256)
-		}
-
-		// Set headers and send response
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write(largeResponse)
-	}))
-	defer server.Close()
-
-	// Store original client and restore after test
-	originalClient := cfg.Client.FastProxyClient
-	defer func() {
-		cfg.Client.FastProxyClient = originalClient
-	}()
-
-	// Configure client for test
-	cfg.Client.ClientTimeout = 10 // Longer timeout for large response
-	cfg.Client.FastProxyClient = createFasthttpClient(cfg)
-
-	// Configure server URL
-	cfg.Server.HostGraphQL = server.URL
-
-	// Create request context
-	reqCtx := &fasthttp.RequestCtx{}
-	reqCtx.Request.SetRequestURI("/graphql")
-	reqCtx.Request.Header.SetMethod("POST")
-	reqCtx.Request.Header.Set("Content-Type", "application/json")
-	reqCtx.Request.SetBody([]byte(`{"query": "query { test }"}`))
-
-	// Create fiber context
-	ctx := suite.app.AcquireCtx(reqCtx)
-	defer suite.app.ReleaseCtx(ctx)
-
-	// Call the proxy function
-	err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
-
-	// Verify large response handling
-	suite.Nil(err, "proxyTheRequest should handle large responses")
-	suite.Equal(fiber.StatusOK, ctx.Response().StatusCode(), "Status should be 200 OK")
-	suite.Equal(1024*1024, len(ctx.Response().Body()), "Response body should match expected size")
-}
-
-// Helper function to create gzipped data
-func createGzippedData(data []byte) []byte {
-	var buf bytes.Buffer
-	gw := gzip.NewWriter(&buf)
-	_, _ = gw.Write(data)
-	_ = gw.Close()
-	return buf.Bytes()
-}

integration_security_test.go

@@ -1,674 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/gofiber/fiber/v2"
-	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/suite"
-)
-
-type IntegrationSecurityTestSuite struct {
-	suite.Suite
-	proxyApp    *fiber.App
-	apiApp      *fiber.App
-	logger      *libpack_logger.Logger
-	tempDir     string
-	validAPIKey string
-}
-
-func TestIntegrationSecurityTestSuite(t *testing.T) {
-	suite.Run(t, new(IntegrationSecurityTestSuite))
-}
-
-func (suite *IntegrationSecurityTestSuite) SetupTest() {
-	// Create temporary directory for test files
-	var err error
-	suite.tempDir, err = os.MkdirTemp("", "security_integration_test")
-	suite.NoError(err)
-
-	// Setup configuration
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New()
-	suite.logger = cfg.Logger
-
-	// Configure security settings
-	suite.validAPIKey = "integration-test-api-key-secure-12345"
-	os.Setenv("GMP_ADMIN_API_KEY", suite.validAPIKey)
-
-	// Setup cache for testing
-	cacheConfig := &libpack_cache.CacheConfig{
-		Logger: cfg.Logger,
-		TTL:    60,
-	}
-	cacheConfig.Memory.MaxMemorySize = 10 * 1024 * 1024 // 10MB
-	cacheConfig.Memory.MaxEntries = 1000
-	libpack_cache.EnableCache(cacheConfig)
-
-	// Setup banned users file in temp directory
-	cfg.Api.BannedUsersFile = filepath.Join(suite.tempDir, "banned_users.json")
-
-	// Create test apps
-	suite.setupTestApps()
-}
-
-func (suite *IntegrationSecurityTestSuite) TearDownTest() {
-	// Clean up environment
-	os.Unsetenv("GMP_ADMIN_API_KEY")
-	os.Unsetenv("ADMIN_API_KEY")
-
-	// Clean up temporary directory
-	os.RemoveAll(suite.tempDir)
-}
-
-// tempDirShouldBeAllowed checks if the temp directory is in an allowed location
-func (suite *IntegrationSecurityTestSuite) tempDirShouldBeAllowed() bool {
-	absPath, err := filepath.Abs(suite.tempDir)
-	if err != nil {
-		return false
-	}
-
-	// Check if temp directory is in allowed locations
-	allowedPrefixes := []string{"/tmp/", "/var/tmp/"}
-	for _, prefix := range allowedPrefixes {
-		if strings.HasPrefix(absPath, prefix) {
-			return true
-		}
-	}
-
-	// Check if it's in the working directory
-	workDir, err := os.Getwd()
-	if err != nil {
-		return false
-	}
-	cleanedWorkDir := filepath.Clean(workDir)
-	return strings.HasPrefix(absPath, cleanedWorkDir+string(filepath.Separator))
-}
-
-func (suite *IntegrationSecurityTestSuite) setupTestApps() {
-	// Setup proxy app (simplified for testing)
-	suite.proxyApp = fiber.New(fiber.Config{
-		DisableStartupMessage: true,
-	})
-
-	// Add proxy routes with security middleware
-	suite.proxyApp.Use(func(c *fiber.Ctx) error {
-		// Add request UUID for tracking
-		c.Locals("request_uuid", fmt.Sprintf("test-uuid-%d", time.Now().UnixNano()))
-		return c.Next()
-	})
-
-	suite.proxyApp.Post("/graphql", func(c *fiber.Ctx) error {
-		// Simulate GraphQL proxy behavior with logging
-		if cfg.LogLevel == "DEBUG" {
-			logDebugRequest(c)
-		}
-
-		// Mock GraphQL response
-		response := map[string]interface{}{
-			"data": map[string]interface{}{
-				"user": map[string]interface{}{
-					"id":    "12345",
-					"name":  "Test User",
-					"email": "test@example.com",
-				},
-			},
-		}
-
-		c.Set("Content-Type", "application/json")
-		if cfg.LogLevel == "DEBUG" {
-			logDebugResponse(c)
-		}
-
-		return c.JSON(response)
-	})
-
-	// Setup API app
-	suite.apiApp = fiber.New(fiber.Config{
-		DisableStartupMessage: true,
-	})
-
-	api := suite.apiApp.Group("/api")
-	api.Use(authMiddleware)
-	api.Post("/user-ban", apiBanUser)
-	api.Post("/user-unban", apiUnbanUser)
-	api.Post("/cache-clear", apiClearCache)
-	api.Get("/cache-stats", apiCacheStats)
-}
-
-// TestEndToEndSecurity tests complete request flow with security checks
-func (suite *IntegrationSecurityTestSuite) TestEndToEndSecurity() {
-	suite.Run("GraphQL request with sensitive data logging", func() {
-		// Set debug mode to test logging sanitization
-		originalLogLevel := cfg.LogLevel
-		cfg.LogLevel = "DEBUG"
-		defer func() { cfg.LogLevel = originalLogLevel }()
-
-		// Create GraphQL request with sensitive data
-		graphqlQuery := map[string]interface{}{
-			"query": `
-				mutation LoginUser($input: LoginInput!) {
-					login(input: $input) {
-						user { id name }
-						token
-					}
-				}
-			`,
-			"variables": map[string]interface{}{
-				"input": map[string]interface{}{
-					"email":    "user@example.com",
-					"password": "secret123password",
-					"api_key":  "sk-sensitive-key-123",
-				},
-			},
-		}
-
-		requestBody, err := json.Marshal(graphqlQuery)
-		suite.NoError(err)
-
-		req, err := http.NewRequest("POST", "/graphql", bytes.NewBuffer(requestBody))
-		suite.NoError(err)
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("Authorization", "Bearer sensitive-token-123")
-
-		resp, err := suite.proxyApp.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode)
-
-		// Verify response doesn't contain sensitive data in logs
-		// This would be verified through log capture in a real implementation
-	})
-}
-
-// TestAPISecurityFlow tests complete API security workflow
-func (suite *IntegrationSecurityTestSuite) TestAPISecurityFlow() {
-	tests := []struct {
-		body           map[string]interface{}
-		name           string
-		endpoint       string
-		method         string
-		apiKey         string
-		description    string
-		expectedStatus int
-	}{
-		{
-			name:           "Unauthorized ban attempt",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			apiKey:         "",
-			body:           map[string]interface{}{"user_id": "malicious-user", "reason": "test ban"},
-			expectedStatus: 401,
-			description:    "Should reject unauthorized ban attempts",
-		},
-		{
-			name:           "SQL injection in API key",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			apiKey:         "' OR '1'='1 --",
-			body:           map[string]interface{}{"user_id": "test-user", "reason": "test ban"},
-			expectedStatus: 401,
-			description:    "Should reject SQL injection in API key",
-		},
-		{
-			name:           "Valid ban request",
-			endpoint:       "/api/user-ban",
-			method:         "POST",
-			apiKey:         suite.validAPIKey,
-			body:           map[string]interface{}{"user_id": "test-user-ban", "reason": "test ban reason"},
-			expectedStatus: 200,
-			description:    "Should accept valid ban request",
-		},
-		{
-			name:           "Cache clear without auth",
-			endpoint:       "/api/cache-clear",
-			method:         "POST",
-			apiKey:         "",
-			body:           nil,
-			expectedStatus: 401,
-			description:    "Should reject unauthorized cache clear",
-		},
-		{
-			name:           "Valid cache clear",
-			endpoint:       "/api/cache-clear",
-			method:         "POST",
-			apiKey:         suite.validAPIKey,
-			body:           nil,
-			expectedStatus: 200,
-			description:    "Should accept authorized cache clear",
-		},
-		{
-			name:           "Cache stats without auth",
-			endpoint:       "/api/cache-stats",
-			method:         "GET",
-			apiKey:         "",
-			body:           nil,
-			expectedStatus: 401,
-			description:    "Should reject unauthorized cache stats",
-		},
-		{
-			name:           "Valid cache stats",
-			endpoint:       "/api/cache-stats",
-			method:         "GET",
-			apiKey:         suite.validAPIKey,
-			body:           nil,
-			expectedStatus: 200,
-			description:    "Should accept authorized cache stats",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			var req *http.Request
-			var err error
-
-			if tt.body != nil {
-				bodyBytes, _ := json.Marshal(tt.body)
-				req, err = http.NewRequest(tt.method, tt.endpoint, bytes.NewBuffer(bodyBytes))
-				suite.NoError(err)
-				req.Header.Set("Content-Type", "application/json")
-			} else {
-				req, err = http.NewRequest(tt.method, tt.endpoint, nil)
-				suite.NoError(err)
-			}
-
-			if tt.apiKey != "" {
-				req.Header.Set("X-API-Key", tt.apiKey)
-			}
-
-			resp, err := suite.apiApp.Test(req)
-			suite.NoError(err)
-
-			suite.Equal(tt.expectedStatus, resp.StatusCode,
-				"Status mismatch for %s: %s", tt.name, tt.description)
-		})
-	}
-}
-
-// TestFilePathSecurityIntegration tests path traversal prevention in real scenarios
-func (suite *IntegrationSecurityTestSuite) TestFilePathSecurityIntegration() {
-	tests := []struct {
-		name            string
-		requestedPath   string
-		description     string
-		shouldBeAllowed bool
-	}{
-		{
-			name:            "Valid temp file",
-			requestedPath:   filepath.Join(suite.tempDir, "valid_file.json"),
-			shouldBeAllowed: suite.tempDirShouldBeAllowed(), // Check if tempDir is in allowed paths
-			description:     "Temp directory handling based on system temp location",
-		},
-		{
-			name:            "Path traversal attempt",
-			requestedPath:   "../../../../etc/passwd",
-			shouldBeAllowed: false,
-			description:     "Path traversal should be blocked",
-		},
-		{
-			name:            "Null byte injection",
-			requestedPath:   "/tmp/file.txt\x00.jpg",
-			shouldBeAllowed: false,
-			description:     "Null byte injection should be blocked",
-		},
-		{
-			name:            "Current directory access",
-			requestedPath:   "./config.json",
-			shouldBeAllowed: true,
-			description:     "Current directory should be allowed",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			_, err := validateFilePath(tt.requestedPath)
-
-			if tt.shouldBeAllowed {
-				suite.NoError(err, "Path should be allowed: %s", tt.description)
-			} else {
-				suite.Error(err, "Path should be rejected: %s", tt.description)
-			}
-		})
-	}
-}
-
-// TestConcurrentSecurityOperations tests security under concurrent load
-func (suite *IntegrationSecurityTestSuite) TestConcurrentSecurityOperations() {
-	const numGoroutines = 20
-	const numRequestsPerGoroutine = 10
-
-	suite.Run("Concurrent API authentication", func() {
-		var wg sync.WaitGroup
-		results := make(chan int, numGoroutines*numRequestsPerGoroutine)
-
-		// Mix of valid and invalid API keys
-		apiKeys := []string{
-			suite.validAPIKey, // Valid
-			"invalid-key-1",   // Invalid
-			"invalid-key-2",   // Invalid
-			"' OR '1'='1",     // SQL injection attempt
-			suite.validAPIKey, // Valid
-			"",                // Empty
-		}
-
-		for i := 0; i < numGoroutines; i++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
-
-				for j := 0; j < numRequestsPerGoroutine; j++ {
-					keyIndex := (goroutineID + j) % len(apiKeys)
-					apiKey := apiKeys[keyIndex]
-
-					req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-					if err != nil {
-						results <- 500
-						continue
-					}
-
-					if apiKey != "" {
-						req.Header.Set("X-API-Key", apiKey)
-					}
-
-					resp, err := suite.apiApp.Test(req)
-					if err != nil {
-						results <- 500
-						continue
-					}
-
-					results <- resp.StatusCode
-				}
-			}(i)
-		}
-
-		wg.Wait()
-		close(results)
-
-		// Analyze results
-		statusCounts := make(map[int]int)
-		totalRequests := 0
-		for status := range results {
-			statusCounts[status]++
-			totalRequests++
-		}
-
-		suite.Equal(numGoroutines*numRequestsPerGoroutine, totalRequests,
-			"Should process all requests")
-		suite.Greater(statusCounts[200], 0, "Should have some successful requests")
-		suite.Greater(statusCounts[401], 0, "Should have some rejected requests")
-		suite.Equal(0, statusCounts[500], "Should not have server errors")
-	})
-}
-
-// TestSecurityEventLogging tests that security events are properly logged
-func (suite *IntegrationSecurityTestSuite) TestSecurityEventLogging() {
-	// This would require log capture mechanism in a real implementation
-	suite.Run("Security event logging", func() {
-		// Test unauthorized access logging
-		req, err := http.NewRequest("POST", "/api/user-ban", bytes.NewBuffer([]byte(`{"user_id": "test", "reason": "test ban"}`)))
-		suite.NoError(err)
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("X-API-Key", "invalid-key")
-
-		resp, err := suite.apiApp.Test(req)
-		suite.NoError(err)
-		suite.Equal(401, resp.StatusCode)
-
-		// In a real implementation, we would verify that:
-		// 1. Unauthorized access attempt was logged
-		// 2. No sensitive data was included in logs
-		// 3. Appropriate log level was used
-	})
-}
-
-// TestRateLimitingIntegration tests rate limiting under security scenarios
-func (suite *IntegrationSecurityTestSuite) TestRateLimitingIntegration() {
-	// This would test rate limiting if implemented
-	suite.Run("Rate limiting for security", func() {
-		// Rapid unauthorized requests
-		const numRequests = 100
-		unauthorizedCount := 0
-
-		for i := 0; i < numRequests; i++ {
-			req, err := http.NewRequest("POST", "/api/user-ban",
-				bytes.NewBuffer([]byte(`{"user_id": "test", "reason": "test ban"}`)))
-			suite.NoError(err)
-			req.Header.Set("Content-Type", "application/json")
-			req.Header.Set("X-API-Key", "invalid-key")
-
-			resp, err := suite.apiApp.Test(req)
-			suite.NoError(err)
-
-			if resp.StatusCode == 401 {
-				unauthorizedCount++
-			}
-		}
-
-		// All should be unauthorized (no rate limiting implemented yet)
-		suite.Equal(numRequests, unauthorizedCount,
-			"All unauthorized requests should be rejected")
-	})
-}
-
-// TestSecurityHeadersIntegration tests security-related headers
-func (suite *IntegrationSecurityTestSuite) TestSecurityHeadersIntegration() {
-	suite.Run("Security headers in responses", func() {
-		req, err := http.NewRequest("GET", "/api/cache-stats", nil)
-		suite.NoError(err)
-		req.Header.Set("X-API-Key", suite.validAPIKey)
-
-		resp, err := suite.apiApp.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode)
-
-		// Check for security headers (if implemented)
-		// In a production system, you'd want headers like:
-		// - X-Content-Type-Options: nosniff
-		// - X-Frame-Options: DENY
-		// - X-XSS-Protection: 1; mode=block
-	})
-}
-
-// TestDataSanitizationIntegration tests end-to-end data sanitization
-func (suite *IntegrationSecurityTestSuite) TestDataSanitizationIntegration() {
-	suite.Run("Request/Response sanitization", func() {
-		// Enable debug logging to test sanitization
-		originalLogLevel := cfg.LogLevel
-		cfg.LogLevel = "DEBUG"
-		defer func() { cfg.LogLevel = originalLogLevel }()
-
-		// Create request with sensitive data
-		sensitiveData := map[string]interface{}{
-			"query": "{ user { id name } }",
-			"variables": map[string]interface{}{
-				"password":    "secret123",
-				"api_key":     "sk-sensitive-123",
-				"credit_card": "4111111111111111",
-			},
-		}
-
-		bodyBytes, err := json.Marshal(sensitiveData)
-		suite.NoError(err)
-
-		req, err := http.NewRequest("POST", "/graphql", bytes.NewBuffer(bodyBytes))
-		suite.NoError(err)
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("Authorization", "Bearer sensitive-token")
-
-		resp, err := suite.proxyApp.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode)
-
-		// Verify response
-		body, err := io.ReadAll(resp.Body)
-		suite.NoError(err)
-
-		var response map[string]interface{}
-		err = json.Unmarshal(body, &response)
-		suite.NoError(err)
-
-		suite.Contains(response, "data")
-		// In debug mode, logs would contain sanitized data (tested separately)
-	})
-}
-
-// TestErrorHandlingSecurityIntegration tests secure error handling
-func (suite *IntegrationSecurityTestSuite) TestErrorHandlingSecurityIntegration() {
-	tests := []struct {
-		name        string
-		endpoint    string
-		method      string
-		body        string
-		description string
-	}{
-		{
-			name:        "Malformed JSON",
-			endpoint:    "/api/user-ban",
-			method:      "POST",
-			body:        `{"invalid": json}`,
-			description: "Should handle malformed JSON securely",
-		},
-		{
-			name:        "Missing content type",
-			endpoint:    "/api/user-ban",
-			method:      "POST",
-			body:        `{"user_id": "test", "reason": "test ban"}`,
-			description: "Should handle missing content type",
-		},
-		{
-			name:        "Empty body",
-			endpoint:    "/api/user-ban",
-			method:      "POST",
-			body:        "",
-			description: "Should handle empty body",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			req, err := http.NewRequest(tt.method, tt.endpoint, strings.NewReader(tt.body))
-			suite.NoError(err)
-			req.Header.Set("X-API-Key", suite.validAPIKey)
-			if tt.name != "Missing content type" {
-				req.Header.Set("Content-Type", "application/json")
-			}
-
-			resp, err := suite.apiApp.Test(req)
-			suite.NoError(err)
-
-			// Should not return 500 errors for client errors
-			suite.NotEqual(500, resp.StatusCode, "Should not return server error for client error")
-
-			// Error response should not contain sensitive information
-			if resp.StatusCode >= 400 {
-				body, err := io.ReadAll(resp.Body)
-				suite.NoError(err)
-
-				bodyStr := strings.ToLower(string(body))
-				suite.NotContains(bodyStr, "stack", "Error should not contain stack trace")
-				suite.NotContains(bodyStr, "panic", "Error should not contain panic details")
-				suite.NotContains(bodyStr, "internal", "Error should not leak internal details")
-			}
-		})
-	}
-}
-
-// TestComprehensiveSecurityScenario tests a complete security scenario
-func (suite *IntegrationSecurityTestSuite) TestComprehensiveSecurityScenario() {
-	suite.Run("Complete security workflow", func() {
-		// 1. Attempt SQL injection via GraphQL
-		maliciousGraphQL := map[string]interface{}{
-			"query": "{ user(id: \"'; DROP TABLE users; --\") { id } }",
-		}
-
-		bodyBytes, _ := json.Marshal(maliciousGraphQL)
-		req, _ := http.NewRequest("POST", "/graphql", bytes.NewBuffer(bodyBytes))
-		req.Header.Set("Content-Type", "application/json")
-
-		resp, err := suite.proxyApp.Test(req)
-		suite.NoError(err)
-		// Should not crash or return server error
-		suite.NotEqual(500, resp.StatusCode)
-
-		// 2. Attempt path traversal via API (if file operations were exposed)
-		maliciousPath := "../../../../etc/passwd"
-		_, err = validateFilePath(maliciousPath)
-		suite.Error(err, "Path traversal should be blocked")
-
-		// 3. Attempt unauthorized admin access
-		req, _ = http.NewRequest("POST", "/api/cache-clear", nil)
-		// No API key provided
-
-		resp, err = suite.apiApp.Test(req)
-		suite.NoError(err)
-		suite.Equal(401, resp.StatusCode, "Should reject unauthorized access")
-
-		// 4. Test with valid credentials
-		req, _ = http.NewRequest("GET", "/api/cache-stats", nil)
-		req.Header.Set("X-API-Key", suite.validAPIKey)
-
-		resp, err = suite.apiApp.Test(req)
-		suite.NoError(err)
-		suite.Equal(200, resp.StatusCode, "Should accept valid credentials")
-
-		// 5. Verify no sensitive data in logs (would need log capture)
-		// This would be tested in a real implementation with log capture
-	})
-}
-
-// BenchmarkSecurityOperations benchmarks security-related operations
-func BenchmarkSecurityOperations(b *testing.B) {
-	// Setup
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New()
-
-	validAPIKey := "benchmark-api-key"
-	os.Setenv("GMP_ADMIN_API_KEY", validAPIKey)
-	defer os.Unsetenv("GMP_ADMIN_API_KEY")
-
-	app := fiber.New(fiber.Config{DisableStartupMessage: true})
-	api := app.Group("/api")
-	api.Use(authMiddleware)
-	api.Get("/test", func(c *fiber.Ctx) error {
-		return c.JSON(fiber.Map{"status": "ok"})
-	})
-
-	b.ResetTimer()
-
-	b.Run("API Authentication", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			req, _ := http.NewRequest("GET", "/api/test", nil)
-			req.Header.Set("X-API-Key", validAPIKey)
-			app.Test(req)
-		}
-	})
-
-	b.Run("Path Validation", func(b *testing.B) {
-		for i := 0; i < b.N; i++ {
-			validateFilePath("./test/file.txt")
-		}
-	})
-
-	b.Run("Log Sanitization", func(b *testing.B) {
-		testData := map[string]interface{}{
-			"password": "secret123",
-			"api_key":  "sk-123456",
-			"data":     "normal data",
-		}
-		jsonData, _ := json.Marshal(testData)
-
-		for i := 0; i < b.N; i++ {
-			sanitizeForLogging(jsonData, "application/json")
-		}
-	})
-}

interval_test.go

@@ -1,106 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/goccy/go-json"
-)
-
-// Test_IntervalConversion tests the conversion of various interval formats
-func (suite *Tests) Test_IntervalConversion() {
-	// Test cases for string-based intervals
-	testCases := []struct {
-		name             string
-		jsonString       string
-		expectedDuration time.Duration
-		shouldError      bool
-	}{
-		{
-			name:             "second string",
-			jsonString:       `{"interval": "second", "req": 100}`,
-			expectedDuration: time.Second,
-			shouldError:      false,
-		},
-		{
-			name:             "minute string",
-			jsonString:       `{"interval": "minute", "req": 5}`,
-			expectedDuration: time.Minute,
-			shouldError:      false,
-		},
-		{
-			name:             "hour string",
-			jsonString:       `{"interval": "hour", "req": 1000}`,
-			expectedDuration: time.Hour,
-			shouldError:      false,
-		},
-		{
-			name:             "day string",
-			jsonString:       `{"interval": "day", "req": 10000}`,
-			expectedDuration: 24 * time.Hour,
-			shouldError:      false,
-		},
-		{
-			name:             "numeric value in seconds",
-			jsonString:       `{"interval": 30, "req": 50}`,
-			expectedDuration: 30 * time.Second,
-			shouldError:      false,
-		},
-		{
-			name:             "go duration format",
-			jsonString:       `{"interval": "5s", "req": 50}`,
-			expectedDuration: 5 * time.Second,
-			shouldError:      false,
-		},
-		{
-			name:             "invalid format",
-			jsonString:       `{"interval": "invalid", "req": 100}`,
-			expectedDuration: 0,
-			shouldError:      true,
-		},
-	}
-
-	// Run the tests
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			var config RateLimitConfig
-			err := json.Unmarshal([]byte(tc.jsonString), &config)
-
-			if tc.shouldError {
-				suite.Error(err, "Expected error for invalid format")
-			} else {
-				suite.NoError(err, "Unexpected error during unmarshal")
-				suite.Equal(tc.expectedDuration, config.Interval,
-					fmt.Sprintf("Expected %v but got %v", tc.expectedDuration, config.Interval))
-				suite.NotNil(config.Interval, "Interval should not be nil")
-			}
-		})
-	}
-}
-
-// Test_LoadRatelimitConfigFile tests the actual loading of the configuration file
-func (suite *Tests) Test_LoadRatelimitConfigFile() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	err := loadRatelimitConfig()
-	suite.NoError(err, "Should load ratelimit config without error")
-
-	// Verify that rate limits were loaded
-	suite.NotEmpty(rateLimits, "Rate limits should not be empty")
-
-	// Check specific roles
-	suite.Contains(rateLimits, "admin", "Should contain admin role")
-	suite.Contains(rateLimits, "guest", "Should contain guest role")
-	suite.Contains(rateLimits, "-", "Should contain default role")
-
-	// Verify interval values
-	suite.Equal(time.Second, rateLimits["admin"].Interval, "Admin should have 1 second interval")
-	suite.Equal(time.Second, rateLimits["guest"].Interval, "Guest should have 1 second interval")
-	suite.Equal(time.Minute, rateLimits["-"].Interval, "Default role should have 1 minute interval")
-
-	// Verify request limits
-	suite.Equal(100, rateLimits["admin"].Req, "Admin should allow 100 req/second")
-	suite.Equal(3, rateLimits["guest"].Req, "Guest should allow 3 req/second")
-	suite.Equal(10, rateLimits["-"].Req, "Default role should allow 10 req/minute")
-}

logging/logger.go

@@ -42,7 +42,6 @@ type Logger struct {
 	timeFormat  string
 	minLogLevel int
 	showCaller  bool
-	mu          sync.Mutex // Mutex to protect concurrent access to output
 }
 
 // LogMessage represents a log message with optional pairs.
@@ -65,12 +64,6 @@ var fieldNames = map[string]string{
 	"message":   "message",
 }
 
-// osExit is a variable to allow mocking os.Exit in tests
-var osExit = os.Exit
-
-// exitMutex ensures thread-safe access to osExit
-var exitMutex sync.RWMutex
-
 // New creates a new Logger with default settings.
 func New() *Logger {
 	return &Logger{
@@ -83,9 +76,7 @@ func New() *Logger {
 
 // SetOutput sets the output destination for the logger.
 func (l *Logger) SetOutput(output io.Writer) *Logger {
-	l.mu.Lock()
 	l.output = output
-	l.mu.Unlock()
 	return l
 }
 
@@ -153,11 +144,8 @@ func (l *Logger) log(level int, m *LogMessage) {
 		fmt.Fprintln(os.Stderr, "Error marshalling log message:", err)
 		return
 	}
-	// Lock the mutex before writing to the output to prevent race conditions
-	l.mu.Lock()
-	_, err = l.output.Write(buffer.Bytes())
-	l.mu.Unlock()
 
+	_, err = l.output.Write(buffer.Bytes())
 	if err != nil {
 		fmt.Fprintln(os.Stderr, "Error writing log message:", err)
 	}
@@ -206,9 +194,7 @@ func (l *Logger) Fatal(m *LogMessage) {
 // Critical logs a critical-level message and exits the application.
 func (l *Logger) Critical(m *LogMessage) {
 	l.Fatal(m)
-	exitMutex.RLock()
-	defer exitMutex.RUnlock()
-	osExit(1)
+	os.Exit(1)
 }
 
 // getCaller retrieves the file and line number of the caller.

logging/logger_additional_test.go

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

logging/logger_bench_test.go

@@ -55,7 +55,10 @@ func Benchmark_NewLogger(b *testing.B) {
 	for _, tt := range tests {
 		b.Run(tt.name, func(b *testing.B) {
 			for i := 0; i < b.N; i++ {
-				_ = New()
+				logger := New()
+				if tt.triggers.ModLevel.Level != 0 {
+					logger.SetMinLogLevel(tt.triggers.ModLevel.Level)
+				}
 			}
 		})
 	}

logging/logger_race_test.go

@@ -1,54 +0,0 @@
-package libpack_logger
-
-import (
-	"bytes"
-	"sync"
-	"testing"
-)
-
-// Test_LogConcurrentAccess verifies that the logger correctly handles concurrent access
-// without race conditions
-func TestLogConcurrentAccess(t *testing.T) {
-	output := &bytes.Buffer{}
-	logger := New().SetOutput(output).SetMinLogLevel(LEVEL_DEBUG)
-
-	// Number of concurrent goroutines
-	numGoroutines := 100
-	// Wait group to synchronize goroutines
-	var wg sync.WaitGroup
-	wg.Add(numGoroutines)
-
-	// Launch multiple goroutines to log concurrently
-	for i := 0; i < numGoroutines; i++ {
-		go func(id int) {
-			defer wg.Done()
-			msg := &LogMessage{
-				Message: "concurrent log test",
-				Pairs: map[string]interface{}{
-					"goroutine_id": id,
-				},
-			}
-			// Use different log levels to test all paths
-			switch id % 5 {
-			case 0:
-				logger.Debug(msg)
-			case 1:
-				logger.Info(msg)
-			case 2:
-				logger.Warn(msg)
-			case 3:
-				logger.Error(msg)
-			case 4:
-				logger.Fatal(msg)
-			}
-		}(i)
-	}
-
-	// Wait for all goroutines to complete
-	wg.Wait()
-
-	// If we make it here without a race detector failure, the test passes
-	if output.Len() == 0 {
-		t.Error("Expected log output, but got none")
-	}
-}

lru_cache.go

@@ -1,225 +0,0 @@
-package main
-
-import (
-	"container/list"
-	"sync"
-	"time"
-)
-
-// LRUCacheEntry represents a cache entry with metadata
-type LRUCacheEntry struct {
-	timestamp time.Time
-	value     interface{}
-	element   *list.Element
-	key       string
-	size      int64
-}
-
-// LRUCache implements a thread-safe LRU cache with O(1) operations
-type LRUCache struct {
-	entries     map[string]*LRUCacheEntry
-	evictList   *list.List
-	maxEntries  int
-	maxSize     int64
-	currentSize int64
-	mu          sync.RWMutex
-}
-
-// NewLRUCache creates a new LRU cache
-func NewLRUCache(maxEntries int, maxSize int64) *LRUCache {
-	// Ensure non-negative values for safety
-	if maxEntries < 0 {
-		maxEntries = 0
-	}
-	if maxSize < 0 {
-		maxSize = 0
-	}
-
-	return &LRUCache{
-		maxEntries: maxEntries,
-		maxSize:    maxSize,
-		entries:    make(map[string]*LRUCacheEntry),
-		evictList:  list.New(),
-	}
-}
-
-// Get retrieves a value from the cache
-func (c *LRUCache) Get(key string) (interface{}, bool) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	entry, exists := c.entries[key]
-	if !exists {
-		return nil, false
-	}
-
-	// Move to front (most recently used)
-	c.evictList.MoveToFront(entry.element)
-	entry.timestamp = time.Now()
-
-	return entry.value, true
-}
-
-// Set adds or updates a value in the cache
-func (c *LRUCache) Set(key string, value interface{}, size int64) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	// Check if key already exists
-	if entry, exists := c.entries[key]; exists {
-		// Update existing entry
-		c.currentSize -= entry.size
-		c.currentSize += size
-		entry.value = value
-		entry.size = size
-		entry.timestamp = time.Now()
-		c.evictList.MoveToFront(entry.element)
-
-		// Check if we need to evict due to size
-		c.evictIfNeeded()
-		return
-	}
-
-	// Create new entry
-	entry := &LRUCacheEntry{
-		key:       key,
-		value:     value,
-		size:      size,
-		timestamp: time.Now(),
-	}
-
-	// Add to front of list
-	element := c.evictList.PushFront(entry)
-	entry.element = element
-	c.entries[key] = entry
-	c.currentSize += size
-
-	// Evict if necessary
-	c.evictIfNeeded()
-}
-
-// evictIfNeeded removes entries when cache limits are exceeded
-func (c *LRUCache) evictIfNeeded() {
-	// If both limits are zero, don't allow any entries
-	if c.maxEntries == 0 || c.maxSize == 0 {
-		// Clear everything for zero limits
-		c.entries = make(map[string]*LRUCacheEntry)
-		c.evictList = list.New()
-		c.currentSize = 0
-		return
-	}
-
-	// Evict based on entry count
-	for c.evictList.Len() > c.maxEntries {
-		if c.evictList.Len() == 0 {
-			break // Safety check to prevent infinite loop
-		}
-		c.evictOldest()
-	}
-
-	// Evict based on size
-	for c.currentSize > c.maxSize && c.evictList.Len() > 0 {
-		oldSize := c.currentSize
-		c.evictOldest()
-		// Safety check: if size didn't decrease, break to prevent infinite loop
-		if c.currentSize == oldSize {
-			break
-		}
-	}
-}
-
-// evictOldest removes the least recently used entry
-func (c *LRUCache) evictOldest() {
-	element := c.evictList.Back()
-	if element == nil {
-		return
-	}
-
-	entry := element.Value.(*LRUCacheEntry)
-	c.removeEntry(entry)
-}
-
-// removeEntry removes an entry from the cache
-func (c *LRUCache) removeEntry(entry *LRUCacheEntry) {
-	c.evictList.Remove(entry.element)
-	delete(c.entries, entry.key)
-	c.currentSize -= entry.size
-}
-
-// Delete removes a key from the cache
-func (c *LRUCache) Delete(key string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	entry, exists := c.entries[key]
-	if !exists {
-		return
-	}
-
-	c.removeEntry(entry)
-}
-
-// Clear removes all entries from the cache
-func (c *LRUCache) Clear() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	c.entries = make(map[string]*LRUCacheEntry)
-	c.evictList = list.New()
-	c.currentSize = 0
-}
-
-// Len returns the number of entries in the cache
-func (c *LRUCache) Len() int {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	return c.evictList.Len()
-}
-
-// Size returns the current size of the cache in bytes
-func (c *LRUCache) Size() int64 {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-	return c.currentSize
-}
-
-// CleanupExpired removes entries older than the given duration
-func (c *LRUCache) CleanupExpired(maxAge time.Duration) int {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	now := time.Now()
-	removed := 0
-
-	// Iterate from back (oldest) to front (newest)
-	for element := c.evictList.Back(); element != nil; {
-		entry := element.Value.(*LRUCacheEntry)
-
-		// If entry is not expired, we can stop (entries are ordered by access time)
-		if now.Sub(entry.timestamp) <= maxAge {
-			break
-		}
-
-		// Remove expired entry
-		next := element.Prev()
-		c.removeEntry(entry)
-		removed++
-		element = next
-	}
-
-	return removed
-}
-
-// GetStats returns cache statistics
-func (c *LRUCache) GetStats() map[string]interface{} {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return map[string]interface{}{
-		"entries":      c.evictList.Len(),
-		"size_bytes":   c.currentSize,
-		"max_entries":  c.maxEntries,
-		"max_size":     c.maxSize,
-		"fill_percent": float64(c.currentSize) / float64(c.maxSize) * 100,
-	}
-}

lru_cache_test.go

@@ -1,410 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"math/rand"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type LRUCacheTestSuite struct {
-	suite.Suite
-}
-
-func TestLRUCacheTestSuite(t *testing.T) {
-	suite.Run(t, new(LRUCacheTestSuite))
-}
-
-func (suite *LRUCacheTestSuite) TestNewLRUCache() {
-	cache := NewLRUCache(100, 1024*1024) // 100 entries, 1MB
-
-	assert.NotNil(suite.T(), cache)
-	assert.Equal(suite.T(), 0, cache.Len())
-	assert.Equal(suite.T(), int64(0), cache.Size())
-	assert.NotNil(suite.T(), cache.entries)
-	assert.NotNil(suite.T(), cache.evictList)
-}
-
-func (suite *LRUCacheTestSuite) TestGetSet() {
-	cache := NewLRUCache(10, 1024)
-
-	// Test Set and Get
-	cache.Set("key1", "value1", 10)
-	val, exists := cache.Get("key1")
-	assert.True(suite.T(), exists)
-	assert.Equal(suite.T(), "value1", val)
-
-	// Test Get non-existent key
-	val, exists = cache.Get("nonexistent")
-	assert.False(suite.T(), exists)
-	assert.Nil(suite.T(), val)
-}
-
-func (suite *LRUCacheTestSuite) TestUpdateExisting() {
-	cache := NewLRUCache(10, 1024)
-
-	// Set initial value
-	cache.Set("key1", "value1", 10)
-	assert.Equal(suite.T(), int64(10), cache.Size())
-
-	// Update with new value and size
-	cache.Set("key1", "value2", 20)
-	val, exists := cache.Get("key1")
-	assert.True(suite.T(), exists)
-	assert.Equal(suite.T(), "value2", val)
-	assert.Equal(suite.T(), int64(20), cache.Size())
-	assert.Equal(suite.T(), 1, cache.Len())
-}
-
-func (suite *LRUCacheTestSuite) TestEvictionByCount() {
-	cache := NewLRUCache(3, 1024) // Max 3 entries
-
-	// Add 4 entries
-	cache.Set("key1", "value1", 10)
-	cache.Set("key2", "value2", 10)
-	cache.Set("key3", "value3", 10)
-	cache.Set("key4", "value4", 10)
-
-	// Should have evicted key1
-	assert.Equal(suite.T(), 3, cache.Len())
-	_, exists := cache.Get("key1")
-	assert.False(suite.T(), exists)
-
-	// key2, key3, key4 should still exist
-	_, exists = cache.Get("key2")
-	assert.True(suite.T(), exists)
-	_, exists = cache.Get("key3")
-	assert.True(suite.T(), exists)
-	_, exists = cache.Get("key4")
-	assert.True(suite.T(), exists)
-}
-
-func (suite *LRUCacheTestSuite) TestEvictionBySize() {
-	cache := NewLRUCache(10, 100) // Max 100 bytes
-
-	// Add entries that exceed size limit
-	cache.Set("key1", "value1", 40)
-	cache.Set("key2", "value2", 40)
-	cache.Set("key3", "value3", 40) // Total would be 120, should evict key1
-
-	assert.Equal(suite.T(), 2, cache.Len())
-	assert.LessOrEqual(suite.T(), cache.Size(), int64(100))
-
-	// key1 should be evicted
-	_, exists := cache.Get("key1")
-	assert.False(suite.T(), exists)
-
-	// key2 and key3 should exist
-	_, exists = cache.Get("key2")
-	assert.True(suite.T(), exists)
-	_, exists = cache.Get("key3")
-	assert.True(suite.T(), exists)
-}
-
-func (suite *LRUCacheTestSuite) TestLRUOrder() {
-	cache := NewLRUCache(3, 1024)
-
-	// Add 3 entries
-	cache.Set("key1", "value1", 10)
-	cache.Set("key2", "value2", 10)
-	cache.Set("key3", "value3", 10)
-
-	// Access key1 to make it most recently used
-	cache.Get("key1")
-
-	// Add a new entry, should evict key2 (least recently used)
-	cache.Set("key4", "value4", 10)
-
-	_, exists := cache.Get("key1")
-	assert.True(suite.T(), exists) // Should exist (recently accessed)
-	_, exists = cache.Get("key2")
-	assert.False(suite.T(), exists) // Should be evicted
-	_, exists = cache.Get("key3")
-	assert.True(suite.T(), exists) // Should exist
-	_, exists = cache.Get("key4")
-	assert.True(suite.T(), exists) // Should exist (newest)
-}
-
-func (suite *LRUCacheTestSuite) TestDelete() {
-	cache := NewLRUCache(10, 1024)
-
-	cache.Set("key1", "value1", 10)
-	cache.Set("key2", "value2", 20)
-
-	assert.Equal(suite.T(), 2, cache.Len())
-	assert.Equal(suite.T(), int64(30), cache.Size())
-
-	// Delete key1
-	cache.Delete("key1")
-	assert.Equal(suite.T(), 1, cache.Len())
-	assert.Equal(suite.T(), int64(20), cache.Size())
-
-	_, exists := cache.Get("key1")
-	assert.False(suite.T(), exists)
-
-	// Delete non-existent key should be safe
-	cache.Delete("nonexistent")
-	assert.Equal(suite.T(), 1, cache.Len())
-}
-
-func (suite *LRUCacheTestSuite) TestClear() {
-	cache := NewLRUCache(10, 1024)
-
-	// Add multiple entries
-	for i := 0; i < 5; i++ {
-		cache.Set(fmt.Sprintf("key%d", i), fmt.Sprintf("value%d", i), 10)
-	}
-
-	assert.Equal(suite.T(), 5, cache.Len())
-	assert.Equal(suite.T(), int64(50), cache.Size())
-
-	// Clear cache
-	cache.Clear()
-	assert.Equal(suite.T(), 0, cache.Len())
-	assert.Equal(suite.T(), int64(0), cache.Size())
-
-	// Should be able to add new entries
-	cache.Set("newkey", "newvalue", 10)
-	assert.Equal(suite.T(), 1, cache.Len())
-}
-
-func (suite *LRUCacheTestSuite) TestCleanupExpired() {
-	cache := NewLRUCache(10, 1024)
-
-	// Add entries
-	cache.Set("key1", "value1", 10)
-	cache.Set("key2", "value2", 10)
-
-	// Sleep to make entries older
-	time.Sleep(100 * time.Millisecond)
-
-	// Add a new entry
-	cache.Set("key3", "value3", 10)
-
-	// Cleanup entries older than 50ms
-	removed := cache.CleanupExpired(50 * time.Millisecond)
-	assert.Equal(suite.T(), 2, removed) // key1 and key2 should be removed
-
-	assert.Equal(suite.T(), 1, cache.Len())
-	_, exists := cache.Get("key3")
-	assert.True(suite.T(), exists) // key3 should still exist
-}
-
-func (suite *LRUCacheTestSuite) TestGetStats() {
-	cache := NewLRUCache(10, 1000)
-
-	cache.Set("key1", "value1", 100)
-	cache.Set("key2", "value2", 200)
-
-	stats := cache.GetStats()
-
-	assert.Equal(suite.T(), 2, stats["entries"])
-	assert.Equal(suite.T(), int64(300), stats["size_bytes"])
-	assert.Equal(suite.T(), 10, stats["max_entries"])
-	assert.Equal(suite.T(), int64(1000), stats["max_size"])
-	assert.Equal(suite.T(), float64(30), stats["fill_percent"])
-}
-
-func (suite *LRUCacheTestSuite) TestConcurrentAccess() {
-	cache := NewLRUCache(100, 10240)
-	numGoroutines := 10
-	numOperations := 100
-
-	var wg sync.WaitGroup
-	wg.Add(numGoroutines)
-
-	// Run concurrent operations
-	for g := 0; g < numGoroutines; g++ {
-		go func(goroutineID int) {
-			defer wg.Done()
-
-			for i := 0; i < numOperations; i++ {
-				key := fmt.Sprintf("key-%d-%d", goroutineID, i)
-				value := fmt.Sprintf("value-%d-%d", goroutineID, i)
-
-				// Mix of operations
-				switch i % 4 {
-				case 0:
-					cache.Set(key, value, 10)
-				case 1:
-					cache.Get(key)
-				case 2:
-					cache.Delete(fmt.Sprintf("key-%d-%d", goroutineID, i-1))
-				case 3:
-					cache.Len()
-					cache.Size()
-				}
-			}
-		}(g)
-	}
-
-	wg.Wait()
-
-	// Cache should be in a consistent state
-	assert.LessOrEqual(suite.T(), cache.Len(), 100)
-	assert.GreaterOrEqual(suite.T(), cache.Len(), 0)
-}
-
-func (suite *LRUCacheTestSuite) TestConcurrentEviction() {
-	cache := NewLRUCache(10, 1024) // Small cache to trigger evictions
-
-	var wg sync.WaitGroup
-	numGoroutines := 50
-
-	wg.Add(numGoroutines)
-	for g := 0; g < numGoroutines; g++ {
-		go func(id int) {
-			defer wg.Done()
-			for i := 0; i < 100; i++ {
-				key := fmt.Sprintf("key-%d-%d", id, i)
-				cache.Set(key, "value", 10)
-				time.Sleep(time.Microsecond) // Small delay to interleave operations
-			}
-		}(g)
-	}
-
-	wg.Wait()
-
-	// Should never exceed max entries
-	assert.LessOrEqual(suite.T(), cache.Len(), 10)
-	assert.LessOrEqual(suite.T(), cache.Size(), int64(1024))
-}
-
-func (suite *LRUCacheTestSuite) TestRaceCondition() {
-	// This test specifically checks for race conditions
-	cache := NewLRUCache(100, 10240)
-
-	var wg sync.WaitGroup
-	var setCount, getCount, deleteCount int32
-
-	// Writer goroutines
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				key := fmt.Sprintf("key%d", rand.Intn(50))
-				cache.Set(key, "value", 10)
-				atomic.AddInt32(&setCount, 1)
-			}
-		}(i)
-	}
-
-	// Reader goroutines
-	for i := 0; i < 5; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				key := fmt.Sprintf("key%d", rand.Intn(50))
-				cache.Get(key)
-				atomic.AddInt32(&getCount, 1)
-			}
-		}(i)
-	}
-
-	// Deleter goroutines
-	for i := 0; i < 2; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < 50; j++ {
-				key := fmt.Sprintf("key%d", rand.Intn(50))
-				cache.Delete(key)
-				atomic.AddInt32(&deleteCount, 1)
-			}
-		}(i)
-	}
-
-	// Stats reader
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		for i := 0; i < 100; i++ {
-			_ = cache.GetStats()
-			time.Sleep(time.Microsecond)
-		}
-	}()
-
-	// Cleanup goroutine
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		for i := 0; i < 10; i++ {
-			time.Sleep(10 * time.Millisecond)
-			cache.CleanupExpired(5 * time.Millisecond)
-		}
-	}()
-
-	wg.Wait()
-
-	// Verify operations completed
-	assert.Equal(suite.T(), int32(500), atomic.LoadInt32(&setCount))
-	assert.Equal(suite.T(), int32(500), atomic.LoadInt32(&getCount))
-	assert.Equal(suite.T(), int32(100), atomic.LoadInt32(&deleteCount))
-}
-
-func (suite *LRUCacheTestSuite) TestEdgeCases() {
-	// Zero size cache
-	cache := NewLRUCache(0, 0)
-	cache.Set("key", "value", 10)
-	assert.Equal(suite.T(), 0, cache.Len()) // Should not store anything
-
-	// Negative values should be handled
-	cache = NewLRUCache(-1, -1)
-	cache.Set("key", "value", 10)
-	assert.Equal(suite.T(), 0, cache.Len())
-
-	// Very large size
-	cache = NewLRUCache(1, 1)
-	cache.Set("key", "value", 1000)         // Size exceeds limit
-	assert.Equal(suite.T(), 0, cache.Len()) // Should evict immediately
-}
-
-// Benchmark tests
-func BenchmarkLRUCacheSet(b *testing.B) {
-	cache := NewLRUCache(1000, 1024*1024)
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		key := fmt.Sprintf("key%d", i)
-		cache.Set(key, "value", 10)
-	}
-}
-
-func BenchmarkLRUCacheGet(b *testing.B) {
-	cache := NewLRUCache(1000, 1024*1024)
-
-	// Pre-populate cache
-	for i := 0; i < 1000; i++ {
-		key := fmt.Sprintf("key%d", i)
-		cache.Set(key, "value", 10)
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		key := fmt.Sprintf("key%d", i%1000)
-		cache.Get(key)
-	}
-}
-
-func BenchmarkLRUCacheConcurrent(b *testing.B) {
-	cache := NewLRUCache(1000, 1024*1024)
-	b.RunParallel(func(pb *testing.PB) {
-		i := 0
-		for pb.Next() {
-			key := fmt.Sprintf("key%d", i)
-			if i%2 == 0 {
-				cache.Set(key, "value", 10)
-			} else {
-				cache.Get(key)
-			}
-			i++
-		}
-	})
-}

main.go

@@ -3,16 +3,9 @@ package main
 import (
 	"context"
 	"flag"
-	"fmt"
-	"net/url"
 	"os"
-	"os/signal"
-	"path/filepath"
-	"runtime"
-	"strconv"
 	"strings"
 	"sync"
-	"syscall"
 	"time"
 
 	"github.com/gofiber/fiber/v2/middleware/proxy"
@@ -21,84 +14,33 @@ import (
 	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 	libpack_tracing "github.com/lukaszraczylo/graphql-monitoring-proxy/tracing"
 )
 
 var (
-	cfg             *config
-	cfgMutex        sync.RWMutex
-	once            sync.Once
-	tracer          *libpack_tracing.TracingSetup
-	shutdownManager *ShutdownManager
+	cfg    *config
+	once   sync.Once
+	tracer *libpack_tracing.TracingSetup
 )
 
 // getDetailsFromEnv retrieves the value from the environment or returns the default.
-// It first checks for a prefixed environment variable (GMP_KEY), then falls back to the unprefixed version.
 func getDetailsFromEnv[T any](key string, defaultValue T) T {
-	prefixedKey := "GMP_" + key
-
+	var result any
+	envKey := "GMP_" + key
+	if _, ok := os.LookupEnv(envKey); !ok {
+		envKey = key
+	}
 	switch v := any(defaultValue).(type) {
 	case string:
-		if val, ok := os.LookupEnv(prefixedKey); ok {
-			return any(val).(T)
-		}
-		return any(envutil.Getenv(key, v)).(T)
+		result = envutil.Getenv(envKey, v)
 	case int:
-		if val, ok := os.LookupEnv(prefixedKey); ok {
-			if intVal, err := strconv.Atoi(val); err == nil {
-				return any(intVal).(T)
-			}
-		}
-		return any(envutil.GetInt(key, v)).(T)
+		result = envutil.GetInt(envKey, v)
 	case bool:
-		if val, ok := os.LookupEnv(prefixedKey); ok {
-			boolVal := strings.ToLower(val) == "true" || val == "1"
-			return any(boolVal).(T)
-		}
-		return any(envutil.GetBool(key, v)).(T)
+		result = envutil.GetBool(envKey, v)
 	default:
-		return defaultValue
+		result = defaultValue
 	}
-}
-
-// validateJWTClaimPath validates JWT claim paths to prevent injection attacks
-func validateJWTClaimPath(path string) error {
-	if path == "" {
-		return nil // Empty path is valid (feature disabled)
-	}
-
-	// Prevent path traversal attempts
-	if strings.Contains(path, "..") {
-		return fmt.Errorf("invalid JWT claim path (contains '..'): %s", path)
-	}
-
-	// Prevent absolute paths
-	if strings.HasPrefix(path, "/") {
-		return fmt.Errorf("invalid JWT claim path (absolute path not allowed): %s", path)
-	}
-
-	// Limit depth to prevent DoS from deeply nested claims
-	parts := strings.Split(path, ".")
-	if len(parts) > 10 {
-		return fmt.Errorf("invalid JWT claim path (too deep, max 10 levels): %s", path)
-	}
-
-	// Validate each part contains only allowed characters
-	for _, part := range parts {
-		if part == "" {
-			return fmt.Errorf("invalid JWT claim path (empty part): %s", path)
-		}
-		// Allow alphanumeric, underscore, and hyphen
-		for _, ch := range part {
-			if !((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') ||
-				(ch >= '0' && ch <= '9') || ch == '_' || ch == '-') {
-				return fmt.Errorf("invalid JWT claim path (invalid character '%c'): %s", ch, path)
-			}
-		}
-	}
-
-	return nil
+	return result.(T)
 }
 
 // parseConfig loads and parses the configuration.
@@ -113,48 +55,11 @@ func parseConfig() {
 	// Client configurations
 	c.Client.JWTUserClaimPath = getDetailsFromEnv("JWT_USER_CLAIM_PATH", "")
 	c.Client.JWTRoleClaimPath = getDetailsFromEnv("JWT_ROLE_CLAIM_PATH", "")
-
-	// Validate JWT claim paths for security
-	if err := validateJWTClaimPath(c.Client.JWTUserClaimPath); err != nil {
-		fmt.Fprintf(os.Stderr, "❌ CRITICAL ERROR: Invalid JWT_USER_CLAIM_PATH: %v\n", err)
-		os.Exit(1)
-	}
-	if err := validateJWTClaimPath(c.Client.JWTRoleClaimPath); err != nil {
-		fmt.Fprintf(os.Stderr, "❌ CRITICAL ERROR: Invalid JWT_ROLE_CLAIM_PATH: %v\n", err)
-		os.Exit(1)
-	}
-
 	c.Client.RoleFromHeader = getDetailsFromEnv("ROLE_FROM_HEADER", "")
 	c.Client.RoleRateLimit = getDetailsFromEnv("ROLE_RATE_LIMIT", false)
 	// In-memory cache
 	c.Cache.CacheEnable = getDetailsFromEnv("ENABLE_GLOBAL_CACHE", false)
 	c.Cache.CacheTTL = getDetailsFromEnv("CACHE_TTL", 60)
-	c.Cache.CacheMaxMemorySize = getDetailsFromEnv("CACHE_MAX_MEMORY_SIZE", 100) // Default 100MB
-	c.Cache.CacheMaxEntries = getDetailsFromEnv("CACHE_MAX_ENTRIES", 10000)      // Default 10000 entries
-	c.Cache.CacheUseLRU = getDetailsFromEnv("CACHE_USE_LRU", false)              // Use LRU eviction algorithm
-	// GraphQL query parsing cache - auto-calculate based on CPU cores if not set
-	c.Cache.GraphQLQueryCacheSize = getDetailsFromEnv("GRAPHQL_QUERY_CACHE_SIZE", runtime.GOMAXPROCS(0)*250)
-
-	// SECURITY: Per-user cache isolation (enabled by default for security)
-	// Set CACHE_PER_USER_DISABLED=true ONLY if you have a single-user application
-	// or understand the security implications of shared cache across users
-	c.Cache.PerUserCacheDisabled = getDetailsFromEnv("CACHE_PER_USER_DISABLED", false)
-
-	// Log warning if per-user caching is disabled
-	if c.Cache.PerUserCacheDisabled {
-		defer func() {
-			if c.Logger != nil {
-				c.Logger.Warning(&libpack_logging.LogMessage{
-					Message: "⚠️  Per-user cache isolation is DISABLED - Users may see each other's cached data!",
-					Pairs: map[string]interface{}{
-						"security_risk":  "CRITICAL - Do not use in multi-user applications",
-						"recommendation": "Remove CACHE_PER_USER_DISABLED or set it to false",
-					},
-				})
-			}
-		}()
-	}
-
 	// Redis cache
 	c.Cache.CacheRedisEnable = getDetailsFromEnv("ENABLE_REDIS_CACHE", false)
 	c.Cache.CacheRedisURL = getDetailsFromEnv("CACHE_REDIS_URL", "localhost:6379")
@@ -187,88 +92,15 @@ func parseConfig() {
 		}
 		return strings.Split(urls, ",")
 	}()
-
-	// Client timeout and connection configurations with bounds checking
-	clientTimeout := getDetailsFromEnv("PROXIED_CLIENT_TIMEOUT", 120)
-	if clientTimeout < 1 || clientTimeout > 3600 { // 1 second to 1 hour max
-		c.Logger.Warning(&libpack_logging.LogMessage{
-			Message: "Invalid client timeout, using default",
-			Pairs:   map[string]interface{}{"requested": clientTimeout, "default": 120},
-		})
-		clientTimeout = 120
-	}
-	c.Client.ClientTimeout = clientTimeout
-
-	// Configure HTTP connection pool and timeouts with sensible defaults
-	// MaxConnsPerHost limits parallel connections to prevent overwhelming backends
-	maxConns := getDetailsFromEnv("MAX_CONNS_PER_HOST", 1024)
-	if maxConns < 1 || maxConns > 10000 { // Reasonable bounds
-		c.Logger.Warning(&libpack_logging.LogMessage{
-			Message: "Invalid max connections per host, using default",
-			Pairs:   map[string]interface{}{"requested": maxConns, "default": 1024},
-		})
-		maxConns = 1024
-	}
-	c.Client.MaxConnsPerHost = maxConns
-
-	// Configure distinct timeout values for more granular control with bounds checking
-	readTimeout := getDetailsFromEnv("CLIENT_READ_TIMEOUT", c.Client.ClientTimeout)
-	if readTimeout < 1 || readTimeout > 3600 {
-		readTimeout = c.Client.ClientTimeout
-	}
-	c.Client.ReadTimeout = readTimeout
-
-	writeTimeout := getDetailsFromEnv("CLIENT_WRITE_TIMEOUT", c.Client.ClientTimeout)
-	if writeTimeout < 1 || writeTimeout > 3600 {
-		writeTimeout = c.Client.ClientTimeout
-	}
-	c.Client.WriteTimeout = writeTimeout
-
-	// MaxIdleConnDuration controls how long connections stay in the pool
-	idleDuration := getDetailsFromEnv("CLIENT_MAX_IDLE_CONN_DURATION", 300)
-	if idleDuration < 1 || idleDuration > 7200 { // 1 second to 2 hours max
-		idleDuration = 300
-	}
-	c.Client.MaxIdleConnDuration = idleDuration
-
-	// Secure by default: TLS verification is enabled unless explicitly disabled
-	c.Client.DisableTLSVerify = getDetailsFromEnv("CLIENT_DISABLE_TLS_VERIFY", false)
-
-	// Warn if TLS verification is disabled (security risk)
-	if c.Client.DisableTLSVerify {
-		// Logger might not be initialized yet, will log after logger setup
-		defer func() {
-			if c.Logger != nil {
-				c.Logger.Warning(&libpack_logging.LogMessage{
-					Message: "⚠️  TLS certificate verification is DISABLED - This is a security risk in production!",
-					Pairs: map[string]interface{}{
-						"recommendation": "Enable TLS verification by removing CLIENT_DISABLE_TLS_VERIFY or setting it to false",
-					},
-				})
-			}
-		}()
-	}
-
-	// Create HTTP client with the optimized parameters
-	c.Client.FastProxyClient = createFasthttpClient(&c)
+	c.Client.ClientTimeout = getDetailsFromEnv("PROXIED_CLIENT_TIMEOUT", 120)
+	c.Client.FastProxyClient = createFasthttpClient(c.Client.ClientTimeout)
 	proxy.WithClient(c.Client.FastProxyClient) // Setting the global proxy client
 	// API configurations
 	c.Server.EnableApi = getDetailsFromEnv("ENABLE_API", false)
 	c.Server.ApiPort = getDetailsFromEnv("API_PORT", 9090)
-
-	// Validate and sanitize banned users file path to prevent path traversal
-	bannedUsersFile := getDetailsFromEnv("BANNED_USERS_FILE", "/go/src/app/banned_users.json")
-	if validatedPath, err := validateFilePath(bannedUsersFile); err != nil {
-		c.Logger.Error(&libpack_logging.LogMessage{
-			Message: "Invalid banned users file path, using default",
-			Pairs:   map[string]interface{}{"requested": bannedUsersFile, "error": err.Error()},
-		})
-		c.Api.BannedUsersFile = "/go/src/app/banned_users.json"
-	} else {
-		c.Api.BannedUsersFile = validatedPath
-	}
+	c.Api.BannedUsersFile = getDetailsFromEnv("BANNED_USERS_FILE", "/go/src/app/banned_users.json")
 	c.Server.PurgeOnCrawl = getDetailsFromEnv("PURGE_METRICS_ON_CRAWL", false)
-	c.Server.PurgeEvery = getDetailsFromEnv("PURGE_METRICS_ON_TIMER", 1800) // Default: purge metrics every 30 minutes
+	c.Server.PurgeEvery = getDetailsFromEnv("PURGE_METRICS_ON_TIMER", 0)
 	// Hasura event cleaner
 	c.HasuraEventCleaner.Enable = getDetailsFromEnv("HASURA_EVENT_CLEANER", false)
 	c.HasuraEventCleaner.ClearOlderThan = getDetailsFromEnv("HASURA_EVENT_CLEANER_OLDER_THAN", 1)
@@ -276,43 +108,7 @@ func parseConfig() {
 	// Tracing configuration
 	c.Tracing.Enable = getDetailsFromEnv("ENABLE_TRACE", false)
 	c.Tracing.Endpoint = getDetailsFromEnv("TRACE_ENDPOINT", "localhost:4317")
-
-	// Circuit Breaker configuration - optimized for high-traffic production environments
-	c.CircuitBreaker.Enable = getDetailsFromEnv("ENABLE_CIRCUIT_BREAKER", false)
-	c.CircuitBreaker.MaxFailures = getDetailsFromEnv("CIRCUIT_MAX_FAILURES", 10)                    // Higher tolerance for transient failures
-	c.CircuitBreaker.FailureRatio = getDetailsFromEnv("CIRCUIT_FAILURE_RATIO", 0.5)                 // Trip at 50% failure rate
-	c.CircuitBreaker.SampleSize = getDetailsFromEnv("CIRCUIT_SAMPLE_SIZE", 100)                     // Statistically significant sample
-	c.CircuitBreaker.Timeout = getDetailsFromEnv("CIRCUIT_TIMEOUT_SECONDS", 60)                     // Longer recovery time for stability
-	c.CircuitBreaker.MaxRequestsInHalfOpen = getDetailsFromEnv("CIRCUIT_MAX_HALF_OPEN_REQUESTS", 5) // More probe requests
-	c.CircuitBreaker.ReturnCachedOnOpen = getDetailsFromEnv("CIRCUIT_RETURN_CACHED_ON_OPEN", true)
-	c.CircuitBreaker.TripOnTimeouts = getDetailsFromEnv("CIRCUIT_TRIP_ON_TIMEOUTS", true)
-	c.CircuitBreaker.TripOn5xx = getDetailsFromEnv("CIRCUIT_TRIP_ON_5XX", true)
-	c.CircuitBreaker.TripOn4xx = getDetailsFromEnv("CIRCUIT_TRIP_ON_4XX", false)               // 4xx are usually client errors
-	c.CircuitBreaker.BackoffMultiplier = getDetailsFromEnv("CIRCUIT_BACKOFF_MULTIPLIER", 1.0)  // No backoff by default
-	c.CircuitBreaker.MaxBackoffTimeout = getDetailsFromEnv("CIRCUIT_MAX_BACKOFF_TIMEOUT", 300) // 5 minutes max
-	// Initialize endpoint configs map
-	c.CircuitBreaker.EndpointConfigs = make(map[string]*EndpointCBConfig)
-
-	// Retry budget configuration
-	c.RetryBudget.Enable = getDetailsFromEnv("RETRY_BUDGET_ENABLE", true)
-	c.RetryBudget.TokensPerSecond = getDetailsFromEnv("RETRY_BUDGET_TOKENS_PER_SEC", 10.0)
-	c.RetryBudget.MaxTokens = getDetailsFromEnv("RETRY_BUDGET_MAX_TOKENS", 100)
-
-	// Request coalescing configuration
-	c.RequestCoalescing.Enable = getDetailsFromEnv("REQUEST_COALESCING_ENABLE", true)
-
-	// WebSocket configuration
-	c.WebSocket.Enable = getDetailsFromEnv("WEBSOCKET_ENABLE", false)
-	c.WebSocket.PingInterval = getDetailsFromEnv("WEBSOCKET_PING_INTERVAL", 30)
-	c.WebSocket.PongTimeout = getDetailsFromEnv("WEBSOCKET_PONG_TIMEOUT", 60)
-	c.WebSocket.MaxMessageSize = int64(getDetailsFromEnv("WEBSOCKET_MAX_MESSAGE_SIZE", 524288)) // 512KB
-
-	// Admin dashboard configuration
-	c.AdminDashboard.Enable = getDetailsFromEnv("ADMIN_DASHBOARD_ENABLE", true)
-
-	cfgMutex.Lock()
 	cfg = &c
-	cfgMutex.Unlock()
 
 	// Initialize tracing if enabled
 	if cfg.Tracing.Enable {
@@ -341,45 +137,11 @@ func parseConfig() {
 		}
 	}
 
-	// Initialize metrics aggregator FIRST if Redis is enabled (even if cache is disabled)
-	// This allows cluster mode monitoring even when cache is off
-	if cfg.Cache.CacheRedisEnable {
-		cfg.Logger.Info(&libpack_logging.LogMessage{
-			Message: "Initializing metrics aggregator for cluster mode",
-			Pairs: map[string]interface{}{
-				"redis_url": cfg.Cache.CacheRedisURL,
-				"redis_db":  cfg.Cache.CacheRedisDB,
-			},
-		})
-
-		if err := InitializeMetricsAggregator(
-			cfg.Cache.CacheRedisURL,
-			cfg.Cache.CacheRedisPassword,
-			cfg.Cache.CacheRedisDB,
-			cfg.Logger,
-		); err != nil {
-			cfg.Logger.Error(&libpack_logging.LogMessage{
-				Message: "FAILED to initialize metrics aggregator - cluster mode will not work",
-				Pairs: map[string]interface{}{
-					"error": err.Error(),
-				},
-			})
-		} else {
-			cfg.Logger.Info(&libpack_logging.LogMessage{
-				Message: "✓ Metrics aggregator successfully initialized",
-				Pairs: map[string]interface{}{
-					"instance_id": GetMetricsAggregator().GetInstanceID(),
-				},
-			})
-		}
-	}
-
 	// Initialize cache if enabled
 	if cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable {
 		cacheConfig := &libpack_cache.CacheConfig{
-			Logger:               cfg.Logger,
-			TTL:                  cfg.Cache.CacheTTL,
-			PerUserCacheDisabled: cfg.Cache.PerUserCacheDisabled,
+			Logger: cfg.Logger,
+			TTL:    cfg.Cache.CacheTTL,
 		}
 		// Redis cache configurations
 		if cfg.Cache.CacheRedisEnable {
@@ -387,472 +149,35 @@ func parseConfig() {
 			cacheConfig.Redis.URL = cfg.Cache.CacheRedisURL
 			cacheConfig.Redis.Password = cfg.Cache.CacheRedisPassword
 			cacheConfig.Redis.DB = cfg.Cache.CacheRedisDB
-		} else {
-			// Memory cache configurations
-			cacheConfig.Memory.MaxMemorySize = int64(cfg.Cache.CacheMaxMemorySize) * 1024 * 1024 // Convert MB to bytes
-			cacheConfig.Memory.MaxEntries = int64(cfg.Cache.CacheMaxEntries)
-			cacheConfig.Memory.UseLRU = cfg.Cache.CacheUseLRU
-
-			cacheType := "standard"
-			if cfg.Cache.CacheUseLRU {
-				cacheType = "LRU"
-			}
-			cfg.Logger.Info(&libpack_logging.LogMessage{
-				Message: "Configuring memory cache with limits",
-				Pairs: map[string]interface{}{
-					"type":          cacheType,
-					"max_memory_mb": cfg.Cache.CacheMaxMemorySize,
-					"max_entries":   cfg.Cache.CacheMaxEntries,
-				},
-			})
 		}
 		libpack_cache.EnableCache(cacheConfig)
-
-		// Start memory monitoring for in-memory cache if it's not Redis
-		// Will be started with context in main()
 	}
 
-	// Initialize circuit breaker if enabled
-	if cfg.CircuitBreaker.Enable {
-		initCircuitBreaker(cfg)
-	}
-
-	// Note: Retry budget is initialized in main() with context for graceful shutdown
-
-	// Initialize request coalescer
-	if cfg.RequestCoalescing.Enable {
-		InitializeRequestCoalescer(true, cfg.Logger, cfg.Monitoring)
-	}
-
-	// Initialize WebSocket proxy
-	if cfg.WebSocket.Enable {
-		wsConfig := WebSocketConfig{
-			Enabled:        cfg.WebSocket.Enable,
-			PingInterval:   time.Duration(cfg.WebSocket.PingInterval) * time.Second,
-			PongTimeout:    time.Duration(cfg.WebSocket.PongTimeout) * time.Second,
-			MaxMessageSize: cfg.WebSocket.MaxMessageSize,
-		}
-		InitializeWebSocketProxy(cfg.Server.HostGraphQL, wsConfig, cfg.Logger, cfg.Monitoring)
-	}
-
-	// Initialize backend health manager
-	if cfg.Server.HostGraphQL != "" {
-		healthMgr := InitializeBackendHealth(cfg.Client.FastProxyClient, cfg.Server.HostGraphQL, cfg.Logger)
-		// Start health checking in background
-		healthMgr.StartHealthChecking()
-	}
-
-	// Note: RPS tracker is initialized in main() with context for graceful shutdown
-
-	// Load rate limit configuration with improved error handling
-	if err := loadRatelimitConfig(); err != nil {
-		// Log the error with clear guidance
-		detailedError := err.Error()
-		cfg.Logger.Error(&libpack_logging.LogMessage{
-			Message: "Failed to start service due to rate limit configuration error",
-			Pairs: map[string]interface{}{
-				"error": detailedError,
-			},
-		})
-
-		// If we're not in a test environment, print to stderr and exit if config error
-		if ifNotInTest() {
-			fmt.Fprintln(os.Stderr, "⚠️ CRITICAL ERROR: Rate limit configuration problem detected")
-			fmt.Fprintln(os.Stderr, detailedError)
-			os.Exit(1)
-		}
-	}
-	// API and event cleaner will be started with context in main()
+	loadRatelimitConfig()
+	once.Do(func() {
+		go enableApi()
+		go enableHasuraEventCleaner()
+	})
 	prepareQueriesAndExemptions()
-
-	// Initialize GraphQL parsing optimizations
-	initGraphQLParsing()
 }
 
 func main() {
-	// Parse configuration
 	parseConfig()
+	StartMonitoringServer()
+	time.Sleep(5 * time.Second)
+	StartHTTPProxy()
 
-	// Setup graceful shutdown
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	// Initialize shutdown manager
-	shutdownManager = NewShutdownManager(ctx)
-
-	// Initialize RPS tracker with context for graceful shutdown
-	InitializeRPSTracker(ctx)
-	cfg.Logger.Info(&libpack_logging.LogMessage{
-		Message: "RPS tracker initialized",
-	})
-
-	// Initialize retry budget with context for graceful shutdown
-	if cfg.RetryBudget.Enable {
-		retryBudgetConfig := RetryBudgetConfig{
-			TokensPerSecond: cfg.RetryBudget.TokensPerSecond,
-			MaxTokens:       cfg.RetryBudget.MaxTokens,
-			Enabled:         cfg.RetryBudget.Enable,
-		}
-		InitializeRetryBudgetWithContext(ctx, retryBudgetConfig, cfg.Logger)
-	}
-
-	// Create a wait group to manage goroutines
-	var wg sync.WaitGroup
-
-	// Setup signal handling for graceful shutdown
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
-	go func() {
-		<-sigCh
-		cfg.Logger.Info(&libpack_logging.LogMessage{
-			Message: "Shutdown signal received, stopping services...",
-		})
-		cancel()
-	}()
-
-	// Start background services with context
-	once.Do(func() {
-		// Start API server
-		shutdownManager.RunGoroutine("api-server", func(ctx context.Context) {
-			if err := enableApi(ctx); err != nil {
-				cfg.Logger.Error(&libpack_logging.LogMessage{
-					Message: "API server error",
-					Pairs:   map[string]interface{}{"error": err.Error()},
-				})
-			}
-		})
-
-		// Start event cleaner
-		shutdownManager.RunGoroutine("event-cleaner", func(ctx context.Context) {
-			if err := enableHasuraEventCleaner(ctx); err != nil {
-				cfg.Logger.Error(&libpack_logging.LogMessage{
-					Message: "Event cleaner error",
-					Pairs:   map[string]interface{}{"error": err.Error()},
-				})
-			}
-		})
-
-		// Start cache memory monitoring if not using Redis
-		if cfg.Cache.CacheEnable && !cfg.Cache.CacheRedisEnable {
-			shutdownManager.RunGoroutine("cache-memory-monitoring", startCacheMemoryMonitoring)
-		}
-	})
-
-	// Register connection pool for cleanup
-	shutdownManager.RegisterComponent("http-connection-pool", func(ctx context.Context) error {
-		if connectionPoolManager != nil {
-			return connectionPoolManager.Shutdown()
-		}
-		return nil
-	})
-
-	// Register backend health manager for cleanup
-	shutdownManager.RegisterComponent("backend-health-manager", func(ctx context.Context) error {
-		if healthMgr := GetBackendHealthManager(); healthMgr != nil {
-			healthMgr.Shutdown()
-		}
-		return nil
-	})
-
-	// Register metrics aggregator for cleanup
-	shutdownManager.RegisterComponent("metrics-aggregator", func(ctx context.Context) error {
-		if aggregator := GetMetricsAggregator(); aggregator != nil {
-			aggregator.Shutdown()
-		}
-		return nil
-	})
-
-	// Cache shutdown is handled internally by the cache implementation
-
-	// Start monitoring server
-	cfg.Logger.Info(&libpack_logging.LogMessage{
-		Message: "Starting monitoring server...",
-		Pairs:   map[string]interface{}{"port": cfg.Server.PortMonitoring},
-	})
-
-	// Start monitoring server in a goroutine
-	wg.Add(1)
-	monitoringErrCh := make(chan error, 1)
-	go func() {
-		defer wg.Done()
-		if err := StartMonitoringServer(); err != nil {
-			monitoringErrCh <- err
-		}
-	}()
-
-	// Give monitoring server time to initialize
-	select {
-	case err := <-monitoringErrCh:
-		cfg.Logger.Critical(&libpack_logging.LogMessage{
-			Message: "Failed to start monitoring server",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-				"port":  cfg.Server.PortMonitoring,
-			},
-		})
-		os.Exit(1)
-	case <-time.After(2 * time.Second):
-		// Continue if no error received within timeout
-	}
-
-	// Wait for GraphQL backend to be ready before starting proxy
-	if healthMgr := GetBackendHealthManager(); healthMgr != nil {
-		startupTimeout := time.Duration(getDetailsFromEnv("BACKEND_STARTUP_TIMEOUT", 300)) * time.Second
-		cfg.Logger.Info(&libpack_logging.LogMessage{
-			Message: "Waiting for GraphQL backend to be ready",
-			Pairs: map[string]interface{}{
-				"timeout_seconds": int(startupTimeout.Seconds()),
-			},
-		})
-
-		if err := healthMgr.WaitForBackendReady(startupTimeout); err != nil {
-			cfg.Logger.Critical(&libpack_logging.LogMessage{
-				Message: "GraphQL backend did not become ready in time",
-				Pairs: map[string]interface{}{
-					"error":   err.Error(),
-					"timeout": startupTimeout.String(),
-				},
-			})
-			// Don't exit immediately, but warn that backend is not ready
-			cfg.Logger.Warning(&libpack_logging.LogMessage{
-				Message: "Starting proxy anyway - requests will fail until backend becomes available",
-			})
-		}
-	}
-
-	// Start HTTP proxy
-	cfg.Logger.Info(&libpack_logging.LogMessage{
-		Message: "Starting HTTP proxy server...",
-		Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL},
-	})
-
-	// Start HTTP proxy in a goroutine
-	wg.Add(1)
-	proxyErrCh := make(chan error, 1)
-	go func() {
-		defer wg.Done()
-		if err := StartHTTPProxy(); err != nil {
-			proxyErrCh <- err
-		}
-	}()
-
-	// Block for a moment to check for immediate startup errors
-	select {
-	case err := <-proxyErrCh:
-		cfg.Logger.Critical(&libpack_logging.LogMessage{
-			Message: "Failed to start HTTP proxy server",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-				"port":  cfg.Server.PortGraphQL,
-			},
-		})
-		os.Exit(1)
-	case <-time.After(1 * time.Second):
-		// Continue if no error received within timeout
-	}
-
-	// Wait for context cancellation
-	<-ctx.Done()
-
-	// Perform cleanup
-	cfg.Logger.Info(&libpack_logging.LogMessage{
-		Message: "Shutting down services...",
-	})
-
-	// Register tracer shutdown
+	// Cleanup tracing on exit
 	if tracer != nil {
-		shutdownManager.RegisterComponent("tracer", func(ctx context.Context) error {
-			return tracer.Shutdown(ctx)
-		})
-	}
-
-	// Perform graceful shutdown of all components
-	if err := shutdownManager.Shutdown(30 * time.Second); err != nil {
-		cfg.Logger.Error(&libpack_logging.LogMessage{
-			Message: "Error during shutdown",
-			Pairs:   map[string]interface{}{"error": err.Error()},
-		})
-	}
-
-	// Wait for all goroutines to finish (with timeout)
-	waitCh := make(chan struct{})
-	go func() {
-		wg.Wait()
-		close(waitCh)
-	}()
-
-	select {
-	case <-waitCh:
-		cfg.Logger.Info(&libpack_logging.LogMessage{
-			Message: "All services shut down gracefully",
-		})
-	case <-time.After(10 * time.Second):
-		cfg.Logger.Warning(&libpack_logging.LogMessage{
-			Message: "Some services didn't shut down gracefully within timeout",
-		})
-	}
-}
-
-// startCacheMemoryMonitoring polls memory cache usage and updates metrics
-func startCacheMemoryMonitoring(ctx context.Context) {
-	// Check every few seconds (more frequent than cleanup routine)
-	ticker := time.NewTicker(15 * time.Second)
-	defer ticker.Stop()
-
-	cfg.Logger.Info(&libpack_logging.LogMessage{
-		Message: "Starting memory cache monitoring",
-	})
-
-	// Use mutex to protect concurrent access to metrics registration
-	var metricsMutex sync.Mutex
-
-	// Create initial metrics with proper synchronization
-	metricsMutex.Lock()
-	cfg.Monitoring.RegisterMetricsGauge(libpack_monitoring.MetricsCacheMemoryLimit, nil,
-		float64(libpack_cache.GetCacheMaxMemorySize()))
-	metricsMutex.Unlock()
-
-	for {
-		select {
-		case <-ctx.Done():
-			cfg.Logger.Info(&libpack_logging.LogMessage{
-				Message: "Stopping cache memory monitoring",
+		if err := tracer.Shutdown(context.Background()); err != nil {
+			cfg.Logger.Error(&libpack_logging.LogMessage{
+				Message: "Error shutting down tracer",
+				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
-			return
-		case <-ticker.C:
-			// Skip if monitoring not initialized or cache not initialized
-			if cfg.Monitoring == nil || !libpack_cache.IsCacheInitialized() {
-				continue
-			}
-
-			// Get current memory usage atomically
-			memoryUsage := libpack_cache.GetCacheMemoryUsage()
-			memoryLimit := libpack_cache.GetCacheMaxMemorySize()
-
-			// Update metrics with proper synchronization
-			metricsMutex.Lock()
-			cfg.Monitoring.RegisterMetricsGauge(libpack_monitoring.MetricsCacheMemoryUsage, nil,
-				float64(memoryUsage))
-
-			cfg.Monitoring.RegisterMetricsGauge(libpack_monitoring.MetricsCacheMemoryLimit, nil,
-				float64(memoryLimit))
-
-			// Calculate percentage (protect against division by zero)
-			var percentUsed float64
-			if memoryLimit > 0 {
-				percentUsed = float64(memoryUsage) / float64(memoryLimit) * 100.0
-			}
-
-			cfg.Monitoring.RegisterMetricsGauge(libpack_monitoring.MetricsCacheMemoryPercent, nil,
-				percentUsed)
-			metricsMutex.Unlock()
-
-			// Log if memory usage is high (over 80%)
-			if percentUsed > 80.0 {
-				cfg.Logger.Warning(&libpack_logging.LogMessage{
-					Message: "Memory cache usage is high",
-					Pairs: map[string]interface{}{
-						"memory_usage_bytes": memoryUsage,
-						"memory_limit_bytes": memoryLimit,
-						"percent_used":       percentUsed,
-					},
-				})
-			}
 		}
 	}
 }
 
-// validateFilePath validates and sanitizes file paths to prevent path traversal attacks
-func validateFilePath(path string) (string, error) {
-	if path == "" {
-		return "", fmt.Errorf("empty path not allowed")
-	}
-
-	// Reject bare current directory for security
-	if path == "." {
-		return "", fmt.Errorf("bare current directory not allowed")
-	}
-
-	// URL decode the path to detect encoded traversal attempts
-	decodedPath := path
-	if strings.Contains(path, "%") {
-		// Try to decode URL encoding (single and double)
-		for i := 0; i < 3; i++ { // Handle multiple levels of encoding
-			if decoded, err := url.QueryUnescape(decodedPath); err == nil {
-				decodedPath = decoded
-			} else {
-				break
-			}
-		}
-	}
-
-	// Check for path traversal patterns (in both original and decoded)
-	checkPaths := []string{path, decodedPath}
-	for _, checkPath := range checkPaths {
-		if strings.Contains(checkPath, "..") {
-			return "", fmt.Errorf("path traversal attempt detected")
-		}
-	}
-
-	// Check for dangerous characters
-	dangerousChars := []string{";", "|", "\n", "\r"}
-	for _, char := range dangerousChars {
-		if strings.Contains(path, char) {
-			return "", fmt.Errorf("dangerous character detected in path")
-		}
-	}
-
-	// Clean and normalize the path
-	cleaned := filepath.Clean(path)
-
-	// Get absolute path
-	absPath, err := filepath.Abs(cleaned)
-	if err != nil {
-		return "", fmt.Errorf("invalid file path: %w", err)
-	}
-
-	// Get working directory as base
-	workDir, err := os.Getwd()
-	if err != nil {
-		return "", fmt.Errorf("cannot determine working directory: %w", err)
-	}
-
-	// Define allowed directories
-	allowedDirs := []string{
-		workDir,       // Current working directory
-		"/tmp",        // Temporary files
-		"/var/tmp",    // System temporary files
-		"/go/src/app", // Docker container default
-	}
-
-	// Check if the path is within any allowed directory
-	isAllowed := false
-	for _, allowedDir := range allowedDirs {
-		// Ensure both paths are cleaned and absolute for proper comparison
-		cleanedAllowed := filepath.Clean(allowedDir)
-		if strings.HasPrefix(absPath, cleanedAllowed+string(filepath.Separator)) || absPath == cleanedAllowed {
-			isAllowed = true
-			break
-		}
-	}
-
-	if !isAllowed {
-		return "", fmt.Errorf("path not in allowed directories")
-	}
-
-	// Additional security checks
-	if strings.Contains(absPath, "\x00") {
-		return "", fmt.Errorf("null byte in path")
-	}
-
-	// Return the original path if it's within the current working directory and is relative
-	if strings.HasPrefix(absPath, workDir) && !filepath.IsAbs(path) {
-		return path, nil
-	}
-
-	return absPath, nil
-}
-
 // ifNotInTest checks if the program is not running in a test environment.
 func ifNotInTest() bool {
 	return flag.Lookup("test.v") == nil

main_security_test.go

@@ -1,465 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/suite"
-)
-
-type MainSecurityTestSuite struct {
-	suite.Suite
-}
-
-func TestMainSecurityTestSuite(t *testing.T) {
-	suite.Run(t, new(MainSecurityTestSuite))
-}
-
-// isTempPathAllowed checks if a temp path would be allowed by validateFilePath
-func (suite *MainSecurityTestSuite) isTempPathAllowed(path string) bool {
-	absPath, err := filepath.Abs(path)
-	if err != nil {
-		return false
-	}
-
-	// Check if temp path is in allowed locations
-	allowedPrefixes := []string{"/tmp/", "/var/tmp/"}
-	for _, prefix := range allowedPrefixes {
-		if strings.HasPrefix(absPath, prefix) {
-			return true
-		}
-	}
-
-	// Check if it's in the working directory
-	workDir, err := os.Getwd()
-	if err != nil {
-		return false
-	}
-	cleanedWorkDir := filepath.Clean(workDir)
-	return strings.HasPrefix(absPath, cleanedWorkDir+string(filepath.Separator))
-}
-
-// TestValidateFilePathSecurity tests the validateFilePath function for various security scenarios
-func (suite *MainSecurityTestSuite) TestValidateFilePathSecurity() {
-	tests := []struct {
-		name        string
-		inputPath   string
-		description string
-		shouldFail  bool
-	}{
-		// Path traversal attacks
-		{
-			name:        "Basic path traversal with double dots",
-			inputPath:   "../../../../etc/passwd",
-			shouldFail:  true,
-			description: "Should reject basic path traversal attempt",
-		},
-		{
-			name:        "Path traversal with current directory prefix",
-			inputPath:   "./../../etc/passwd",
-			shouldFail:  true,
-			description: "Should reject path traversal even with ./ prefix",
-		},
-		{
-			name:        "Deep path traversal",
-			inputPath:   "../../../../../../../etc/shadow",
-			shouldFail:  true,
-			description: "Should reject deep path traversal attempts",
-		},
-		{
-			name:        "URL encoded path traversal",
-			inputPath:   "%2e%2e%2f%2e%2e%2fetc%2fpasswd",
-			shouldFail:  true,
-			description: "Should reject URL encoded traversal (if decoded)",
-		},
-		{
-			name:        "Double encoded path traversal",
-			inputPath:   "%252e%252e%252f%252e%252e%252fetc%252fpasswd",
-			shouldFail:  true,
-			description: "Should reject double encoded traversal",
-		},
-		{
-			name:        "Mixed case path traversal",
-			inputPath:   "../ETC/passwd",
-			shouldFail:  true,
-			description: "Should reject mixed case traversal attempts",
-		},
-		{
-			name:        "Path traversal with backslashes",
-			inputPath:   "..\\..\\windows\\system32\\drivers\\etc\\hosts",
-			shouldFail:  true,
-			description: "Should reject Windows-style path traversal",
-		},
-
-		// Absolute path attacks
-		{
-			name:        "Absolute path to sensitive file",
-			inputPath:   "/etc/shadow",
-			shouldFail:  true,
-			description: "Should reject absolute path outside allowed directories",
-		},
-		{
-			name:        "Absolute path to system directories",
-			inputPath:   "/bin/bash",
-			shouldFail:  true,
-			description: "Should reject access to system binaries",
-		},
-		{
-			name:        "Absolute path to home directory",
-			inputPath:   "/home/user/.ssh/id_rsa",
-			shouldFail:  true,
-			description: "Should reject access to user directories",
-		},
-		{
-			name:        "Absolute path to proc filesystem",
-			inputPath:   "/proc/self/environ",
-			shouldFail:  true,
-			description: "Should reject access to proc filesystem",
-		},
-
-		// Null byte injection
-		{
-			name:        "Null byte injection",
-			inputPath:   "/tmp/test.txt\x00.jpg",
-			shouldFail:  true,
-			description: "Should reject null byte injection attempts",
-		},
-		{
-			name:        "Null byte in middle of path",
-			inputPath:   "/tmp/test\x00/file.txt",
-			shouldFail:  true,
-			description: "Should reject null bytes anywhere in path",
-		},
-
-		// Symbolic link attempts (path patterns that might be symlinks)
-		{
-			name:        "Suspicious symlink pattern",
-			inputPath:   "./symlink_to_etc",
-			shouldFail:  false, // This is allowed by current logic but would need real symlink detection
-			description: "Pattern that might be a symlink to sensitive location",
-		},
-
-		// Valid paths that should pass
-		{
-			name:        "Valid application directory path",
-			inputPath:   "/go/src/app/banned_users.txt",
-			shouldFail:  false,
-			description: "Should accept valid app directory path",
-		},
-		{
-			name:        "Valid current directory path",
-			inputPath:   "./data/banned_users.txt",
-			shouldFail:  false,
-			description: "Should accept valid relative path",
-		},
-		{
-			name:        "Valid temp directory path",
-			inputPath:   "/tmp/test_file.txt",
-			shouldFail:  false,
-			description: "Should accept valid temp directory path",
-		},
-		{
-			name:        "Valid var/tmp directory path",
-			inputPath:   "/var/tmp/cache_file.json",
-			shouldFail:  false,
-			description: "Should accept valid var/tmp directory path",
-		},
-		{
-			name:        "Valid nested path in app directory",
-			inputPath:   "/go/src/app/config/settings.json",
-			shouldFail:  false,
-			description: "Should accept nested paths in allowed directories",
-		},
-
-		// Edge cases
-		{
-			name:        "Empty path",
-			inputPath:   "",
-			shouldFail:  true,
-			description: "Should reject empty paths",
-		},
-		{
-			name:        "Only dots",
-			inputPath:   "..",
-			shouldFail:  true,
-			description: "Should reject bare double dots",
-		},
-		{
-			name:        "Current directory only",
-			inputPath:   ".",
-			shouldFail:  true,
-			description: "Should reject bare current directory",
-		},
-		{
-			name:        "Root directory",
-			inputPath:   "/",
-			shouldFail:  true,
-			description: "Should reject root directory access",
-		},
-		{
-			name:        "Path with multiple consecutive dots",
-			inputPath:   "./....//....//etc/passwd",
-			shouldFail:  true,
-			description: "Should reject obfuscated path traversal",
-		},
-
-		// Special character attacks
-		{
-			name:        "Path with semicolon",
-			inputPath:   "/tmp/file;rm -rf /",
-			shouldFail:  true,
-			description: "Should handle paths with command injection attempts",
-		},
-		{
-			name:        "Path with pipe",
-			inputPath:   "/tmp/file|cat /etc/passwd",
-			shouldFail:  true,
-			description: "Should handle paths with pipe characters",
-		},
-		{
-			name:        "Path with newline",
-			inputPath:   "/tmp/file\ncat /etc/passwd",
-			shouldFail:  true,
-			description: "Should handle paths with newline injection",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result, err := validateFilePath(tt.inputPath)
-
-			if tt.shouldFail {
-				suite.Error(err, "Expected error for path: %s (%s)", tt.inputPath, tt.description)
-				suite.Empty(result, "Should return empty result on error")
-
-				// Verify error messages don't leak sensitive information
-				if err != nil {
-					errMsg := strings.ToLower(err.Error())
-					suite.NotContains(errMsg, "secret", "Error should not contain 'secret'")
-					suite.NotContains(errMsg, "password", "Error should not contain 'password'")
-					suite.NotContains(errMsg, "key", "Error should not contain 'key'")
-				}
-			} else {
-				suite.NoError(err, "Expected no error for path: %s (%s)", tt.inputPath, tt.description)
-				suite.NotEmpty(result, "Should return validated path")
-				suite.Equal(tt.inputPath, result, "Should return original path when valid")
-			}
-		})
-	}
-}
-
-// TestValidateFilePathConcurrentAccess tests path validation under concurrent conditions
-func (suite *MainSecurityTestSuite) TestValidateFilePathConcurrentAccess() {
-	maliciousPaths := []string{
-		"../../../../etc/passwd",
-		"../../../etc/shadow",
-		"/etc/hosts",
-		"./../../var/log/messages",
-		"/proc/self/environ",
-	}
-
-	suite.Run("Concurrent malicious paths should all be rejected", func() {
-		done := make(chan error, len(maliciousPaths))
-
-		for _, path := range maliciousPaths {
-			go func(p string) {
-				_, err := validateFilePath(p)
-				done <- err
-			}(path)
-		}
-
-		// Collect all results
-		for i := 0; i < len(maliciousPaths); i++ {
-			err := <-done
-			suite.Error(err, "All malicious paths should be rejected concurrently")
-		}
-	})
-}
-
-// TestValidateFilePathWithRealFiles tests validation with actual file system operations
-func (suite *MainSecurityTestSuite) TestValidateFilePathWithRealFiles() {
-	// Create temporary directory and files for testing
-	tempDir, err := os.MkdirTemp("", "path_security_test")
-	suite.NoError(err)
-	defer os.RemoveAll(tempDir)
-
-	// Create a test file
-	testFile := filepath.Join(tempDir, "test.txt")
-	err = os.WriteFile(testFile, []byte("test content"), 0644)
-	suite.NoError(err)
-
-	// Determine if temp file should fail based on system temp location
-	tempFileShouldFail := !suite.isTempPathAllowed(testFile)
-
-	tests := []struct {
-		name       string
-		path       string
-		shouldFail bool
-	}{
-		{
-			name:       "Valid temp file",
-			path:       testFile,
-			shouldFail: tempFileShouldFail, // Depends on system temp location
-		},
-		{
-			name:       "Non-existent file in allowed directory",
-			path:       "/tmp/non_existent.txt",
-			shouldFail: false, // Should pass validation (file existence not checked)
-		},
-		{
-			name:       "Directory instead of file",
-			path:       "/tmp/",
-			shouldFail: false, // Should pass validation
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			_, err := validateFilePath(tt.path)
-			if tt.shouldFail {
-				suite.Error(err)
-			} else {
-				suite.NoError(err)
-			}
-		})
-	}
-}
-
-// TestValidateFilePathEdgeCases tests various edge cases and corner conditions
-func (suite *MainSecurityTestSuite) TestValidateFilePathEdgeCases() {
-	suite.Run("Very long path", func() {
-		// Create a very long path that might cause buffer overflows
-		longPath := "/tmp/" + strings.Repeat("a", 4096) + ".txt"
-		_, err := validateFilePath(longPath)
-		// Should handle gracefully without crashing
-		suite.NoError(err) // Long paths in /tmp/ should be allowed
-	})
-
-	suite.Run("Path with unicode characters", func() {
-		unicodePath := "/tmp/тест.txt" // Russian characters
-		_, err := validateFilePath(unicodePath)
-		suite.NoError(err) // Unicode should be allowed in valid directories
-	})
-
-	suite.Run("Path with spaces", func() {
-		spacePath := "/tmp/file with spaces.txt"
-		_, err := validateFilePath(spacePath)
-		suite.NoError(err) // Spaces should be allowed
-	})
-
-	suite.Run("Path with special but safe characters", func() {
-		specialPath := "/tmp/file-name_123.json"
-		_, err := validateFilePath(specialPath)
-		suite.NoError(err) // Safe special characters should be allowed
-	})
-}
-
-// TestValidateFilePathAllowedDirectories tests the allowed directory logic
-func (suite *MainSecurityTestSuite) TestValidateFilePathAllowedDirectories() {
-	allowedTests := []struct {
-		name string
-		path string
-	}{
-		{"Go app directory", "/go/src/app/config.json"},
-		{"Current directory", "./config.json"},
-		{"Temp directory", "/tmp/cache.json"},
-		{"Var temp directory", "/var/tmp/session.json"},
-	}
-
-	for _, tt := range allowedTests {
-		suite.Run(tt.name, func() {
-			result, err := validateFilePath(tt.path)
-			suite.NoError(err, "Path should be allowed: %s", tt.path)
-			suite.Equal(tt.path, result)
-		})
-	}
-
-	disallowedTests := []struct {
-		name string
-		path string
-	}{
-		{"Home directory", "/home/user/file.txt"},
-		{"Root etc", "/etc/config"},
-		{"System bin", "/bin/executable"},
-		{"Var log", "/var/log/messages"},
-		{"Opt directory", "/opt/app/config"},
-		{"Absolute path without allowed prefix", "/random/path/file.txt"},
-	}
-
-	for _, tt := range disallowedTests {
-		suite.Run(tt.name, func() {
-			_, err := validateFilePath(tt.path)
-			suite.Error(err, "Path should be rejected: %s", tt.path)
-		})
-	}
-}
-
-// TestValidateFilePathBoundaryConditions tests boundary conditions
-func (suite *MainSecurityTestSuite) TestValidateFilePathBoundaryConditions() {
-	suite.Run("Path exactly at allowed prefix boundary", func() {
-		// Test paths that are exactly the allowed prefixes
-		prefixes := []string{"/go/src/app/", "./", "/tmp/", "/var/tmp/"}
-
-		for _, prefix := range prefixes {
-			// Exact prefix should be allowed
-			_, err := validateFilePath(prefix)
-			suite.NoError(err, "Exact prefix should be allowed: %s", prefix)
-
-			// Prefix with filename should be allowed
-			_, err = validateFilePath(prefix + "file.txt")
-			suite.NoError(err, "Prefix with file should be allowed: %s", prefix+"file.txt")
-
-			// Similar but not exact prefix should be rejected (if not otherwise allowed)
-			if prefix != "./" { // Skip this test for "./" as it's tricky
-				similar := prefix[:len(prefix)-1] + "x/"
-				_, err = validateFilePath(similar + "file.txt")
-				if !strings.HasPrefix(similar, "/tmp") && !strings.HasPrefix(similar, "/var/tmp") {
-					suite.Error(err, "Similar but different prefix should be rejected: %s", similar+"file.txt")
-				}
-			}
-		}
-	})
-}
-
-// BenchmarkValidateFilePath benchmarks the path validation function
-func BenchmarkValidateFilePath(b *testing.B) {
-	testPaths := []string{
-		"/go/src/app/config.json",
-		"./data/file.txt",
-		"/tmp/cache.json",
-		"../../../../etc/passwd", // malicious
-		"/etc/shadow",            // malicious
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		for _, path := range testPaths {
-			validateFilePath(path)
-		}
-	}
-}
-
-// TestValidateFilePathErrorMessages tests that error messages are appropriate
-func (suite *MainSecurityTestSuite) TestValidateFilePathErrorMessages() {
-	errorTests := []struct {
-		path             string
-		expectedContains string
-	}{
-		{"", "empty"},
-		{"..", "traversal"},
-		{"../etc/passwd", "traversal"},
-		{"/tmp/file\x00.txt", "null byte"},
-		{"/etc/passwd", "not in allowed"},
-	}
-
-	for _, tt := range errorTests {
-		suite.Run(fmt.Sprintf("Error for %s", tt.path), func() {
-			_, err := validateFilePath(tt.path)
-			suite.Error(err)
-			suite.Contains(strings.ToLower(err.Error()), tt.expectedContains)
-		})
-	}
-}

main_test.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"context"
 	"fmt"
 	"os"
 	"testing"
@@ -11,24 +10,25 @@ import (
 	"github.com/gofiber/fiber/v2"
 	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache/memory"
 	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/assert"
+	assertions "github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 	"github.com/valyala/fasthttp"
 )
 
 type Tests struct {
 	suite.Suite
-	app     *fiber.App
-	ctx     context.Context
-	cancel  context.CancelFunc
-	apiDone chan struct{}
+	app *fiber.App
 }
 
+var (
+	assert *assertions.Assertions
+)
+
 func (suite *Tests) BeforeTest(suiteName, testName string) {
 }
 
 func (suite *Tests) SetupTest() {
-	// Setup test
+	assert = assertions.New(suite.T())
 	suite.app = fiber.New(
 		fiber.Config{
 			DisableStartupMessage: true,
@@ -40,60 +40,31 @@ func (suite *Tests) SetupTest() {
 	// Initialize a simple in-memory cache client for testing purposes
 	libpack_cache.New(5 * time.Minute)
 	parseConfig()
-
-	// Create context with cancel for cleanup
-	suite.ctx, suite.cancel = context.WithCancel(context.Background())
-	suite.apiDone = make(chan struct{})
-
-	// Start API server in goroutine
-	// Temporarily disable API server in tests to isolate issues
-	// go func() {
-	// 	enableApi(suite.ctx)
-	// 	close(suite.apiDone)
-	// }()
-	close(suite.apiDone) // Close immediately since we're not starting the server
-
-	_ = StartMonitoringServer()
-
-	// Update logger with proper synchronization
-	logger := libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(getDetailsFromEnv("LOG_LEVEL", "info")))
-	cfgMutex.Lock()
-	cfg.Logger = logger
-	cfgMutex.Unlock()
-
+	enableApi()
+	StartMonitoringServer()
+	cfg.Logger = libpack_logging.New().SetMinLogLevel(libpack_logging.GetLogLevel(getDetailsFromEnv("LOG_LEVEL", "info")))
 	// Setup environment variables here if needed
-	_ = os.Setenv("GMP_TEST_STRING", "testValue")
-	_ = os.Setenv("GMP_TEST_INT", "123")
-	_ = os.Setenv("GMP_TEST_BOOL", "true")
-	_ = os.Setenv("NON_GMP_TEST_INT", "31337")
+	os.Setenv("GMP_TEST_STRING", "testValue")
+	os.Setenv("GMP_TEST_INT", "123")
+	os.Setenv("GMP_TEST_BOOL", "true")
+	os.Setenv("NON_GMP_TEST_INT", "31337")
 }
 
 // TearDownTest is run after each test to clean up
 func (suite *Tests) TearDownTest() {
-	// Cancel context to shutdown API server
-	if suite.cancel != nil {
-		suite.cancel()
-		// Wait for API server to shutdown
-		select {
-		case <-suite.apiDone:
-		case <-time.After(2 * time.Second):
-			// Timeout waiting for shutdown
-		}
-	}
-
-	// Shutdown connection pool
-	ShutdownConnectionPool()
-
 	// Clean up environment variables here if needed
-	_ = os.Unsetenv("GMP_TEST_STRING")
-	_ = os.Unsetenv("GMP_TEST_INT")
-	_ = os.Unsetenv("GMP_TEST_BOOL")
-	_ = os.Unsetenv("NON_GMP_TEST_INT")
+	os.Unsetenv("GMP_TEST_STRING")
+	os.Unsetenv("GMP_TEST_INT")
+	os.Unsetenv("GMP_TEST_BOOL")
+	os.Unsetenv("NON_GMP_TEST_INT")
 }
 
 // func (suite *Tests) AfterTest(suiteName, testName string) {)
 
 func TestSuite(t *testing.T) {
+	cfg = &config{}
+	parseConfig()
+	StartMonitoringServer()
 	suite.Run(t, new(Tests))
 }
 
@@ -139,33 +110,33 @@ func (suite *Tests) Test_envVariableSetting() {
 	for _, tt := range tests {
 		suite.Run(tt.name, func() {
 			result := getDetailsFromEnv(tt.envKey, tt.defaultValue)
-			assert.Equal(suite.T(), tt.expected, result)
+			assert.Equal(tt.expected, result)
 		})
 	}
 }
 
 func (suite *Tests) Test_getDetailsFromEnv() {
 	tests := []struct {
-		defaultValue interface{}
-		expected     interface{}
 		name         string
 		key          string
+		defaultValue interface{}
 		envValue     string
+		expected     interface{}
 	}{
-		{"default", "envValue", "string value", "TEST_STRING", "envValue"},
-		{0, 123, "int value", "TEST_INT", "123"},
-		{false, true, "bool value", "TEST_BOOL", "true"},
-		{"default", "default", "default value", "NON_EXISTENT", ""},
+		{"string value", "TEST_STRING", "default", "envValue", "envValue"},
+		{"int value", "TEST_INT", 0, "123", 123},
+		{"bool value", "TEST_BOOL", false, "true", true},
+		{"default value", "NON_EXISTENT", "default", "", "default"},
 	}
 
 	for _, tt := range tests {
 		suite.Run(tt.name, func() {
 			if tt.envValue != "" {
-				_ = os.Setenv("GMP_"+tt.key, tt.envValue)
-				defer func() { _ = os.Unsetenv("GMP_" + tt.key) }()
+				os.Setenv("GMP_"+tt.key, tt.envValue)
+				defer os.Unsetenv("GMP_" + tt.key)
 			}
 			result := getDetailsFromEnv(tt.key, tt.defaultValue)
-			assert.Equal(suite.T(), tt.expected, result)
+			assert.Equal(tt.expected, result)
 		})
 	}
 }
@@ -182,22 +153,22 @@ func (suite *Tests) TestIntrospectionEnvironmentConfig() {
 	for _, env := range varsToSave {
 		if val, exists := os.LookupEnv(env); exists {
 			oldEnv[env] = val
-			_ = os.Unsetenv(env)
+			os.Unsetenv(env)
 		}
 	}
 	defer func() {
 		// Restore original env vars
 		for k, v := range oldEnv {
-			_ = os.Setenv(k, v)
+			os.Setenv(k, v)
 		}
 	}()
 
 	tests := []struct {
-		envVars      map[string]string
 		name         string
+		envVars      map[string]string
 		query        string
-		wantEndpoint string
 		wantBlocked  bool
+		wantEndpoint string
 	}{
 		{
 			name: "basic typename allowed",
@@ -266,13 +237,11 @@ func (suite *Tests) TestIntrospectionEnvironmentConfig() {
 		suite.Run(tt.name, func() {
 			// Set test env vars
 			for k, v := range tt.envVars {
-				_ = os.Setenv(k, v)
+				os.Setenv(k, v)
 			}
 
-			// Reset global config with proper synchronization
-			cfgMutex.Lock()
+			// Reset global config
 			cfg = nil
-			cfgMutex.Unlock()
 			parseConfig()
 
 			// Create test request
@@ -283,9 +252,9 @@ func (suite *Tests) TestIntrospectionEnvironmentConfig() {
 			ctx.Request().SetBody([]byte(fmt.Sprintf(`{"query": %q}`, tt.query)))
 
 			result := parseGraphQLQuery(ctx)
-			assert.Equal(suite.T(), tt.wantBlocked, result.shouldBlock)
+			assert.Equal(tt.wantBlocked, result.shouldBlock)
 			for k := range tt.envVars {
-				_ = os.Unsetenv(k)
+				os.Unsetenv(k)
 			}
 		})
 	}

metrics_aggregator.go

@@ -1,831 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"fmt"
-	"os"
-	"strings"
-	"sync"
-	"time"
-
-	"github.com/google/uuid"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/redis/go-redis/v9"
-)
-
-// MetricsAggregator handles distributed metrics collection via Redis
-type MetricsAggregator struct {
-	redisClient  *redis.Client
-	logger       *libpack_logger.Logger
-	instanceID   string
-	publishKey   string
-	ttl          time.Duration
-	publishTimer *time.Ticker
-	ctx          context.Context
-	cancel       context.CancelFunc
-	mu           sync.RWMutex
-}
-
-// InstanceMetrics represents metrics for a single proxy instance
-type InstanceMetrics struct {
-	InstanceID     string                 `json:"instance_id"`
-	Hostname       string                 `json:"hostname"`
-	LastUpdate     time.Time              `json:"last_update"`
-	UptimeSeconds  float64                `json:"uptime_seconds"`
-	Stats          map[string]interface{} `json:"stats"`
-	Cache          map[string]interface{} `json:"cache,omitempty"`         // Full cache details including memory
-	CacheSummary   map[string]interface{} `json:"cache_summary,omitempty"` // Deprecated: kept for compatibility
-	Health         map[string]interface{} `json:"health"`
-	CircuitBreaker map[string]interface{} `json:"circuit_breaker,omitempty"`
-	RetryBudget    map[string]interface{} `json:"retry_budget,omitempty"`
-	Coalescing     map[string]interface{} `json:"coalescing,omitempty"`
-	WebSocketStats map[string]interface{} `json:"websocket,omitempty"`
-	Connections    map[string]interface{} `json:"connections,omitempty"`
-}
-
-// AggregatedMetrics represents combined metrics from all instances
-type AggregatedMetrics struct {
-	TotalInstances   int                        `json:"total_instances"`
-	HealthyInstances int                        `json:"healthy_instances"`
-	LastUpdate       time.Time                  `json:"last_update"`
-	CombinedStats    map[string]interface{}     `json:"combined_stats"`
-	Instances        []InstanceMetrics          `json:"instances"`
-	PerInstanceStats map[string]InstanceMetrics `json:"per_instance_stats"`
-}
-
-var (
-	metricsAggregator *MetricsAggregator
-	aggregatorMutex   sync.RWMutex
-)
-
-// InitializeMetricsAggregator creates and starts the metrics aggregator
-func InitializeMetricsAggregator(redisURL, redisPassword string, redisDB int, logger *libpack_logger.Logger) error {
-	aggregatorMutex.Lock()
-	defer aggregatorMutex.Unlock()
-
-	if metricsAggregator != nil {
-		return nil // Already initialized
-	}
-
-	// Parse Redis URL
-	opt, err := redis.ParseURL(fmt.Sprintf("redis://%s/%d", redisURL, redisDB))
-	if err != nil {
-		return fmt.Errorf("failed to parse Redis URL: %w", err)
-	}
-
-	if redisPassword != "" {
-		opt.Password = redisPassword
-	}
-
-	// Create Redis client with connection timeouts
-	opt.DialTimeout = 2 * time.Second
-	opt.ReadTimeout = 2 * time.Second
-	opt.WriteTimeout = 2 * time.Second
-	opt.PoolTimeout = 3 * time.Second
-	opt.MaxRetries = 2
-
-	client := redis.NewClient(opt)
-
-	// Test connection with detailed error reporting
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	if err := client.Ping(ctx).Err(); err != nil {
-		// Log detailed connection error
-		if logger != nil {
-			logger.Error(&libpack_logger.LogMessage{
-				Message: "❌ CRITICAL: Redis connection test FAILED during initialization",
-				Pairs: map[string]interface{}{
-					"error":        err.Error(),
-					"redis_url":    redisURL,
-					"redis_db":     redisDB,
-					"has_password": redisPassword != "",
-				},
-			})
-		}
-		return fmt.Errorf("failed to connect to Redis: %w", err)
-	}
-
-	// Log successful connection
-	if logger != nil {
-		logger.Info(&libpack_logger.LogMessage{
-			Message: "✓ Redis connection test PASSED",
-			Pairs: map[string]interface{}{
-				"redis_url": redisURL,
-				"redis_db":  redisDB,
-			},
-		})
-	}
-
-	// Generate unique instance ID (hostname + UUID for uniqueness)
-	hostname, _ := os.Hostname()
-	if hostname == "" {
-		hostname = "unknown"
-	}
-	instanceID := fmt.Sprintf("%s-%s", hostname, uuid.New().String()[:8])
-
-	ctx, cancel = context.WithCancel(context.Background())
-
-	aggregator := &MetricsAggregator{
-		redisClient:  client,
-		logger:       logger,
-		instanceID:   instanceID,
-		publishKey:   "graphql-proxy:metrics:instances",
-		ttl:          30 * time.Second, // Metrics expire after 30s if not updated
-		publishTimer: time.NewTicker(5 * time.Second),
-		ctx:          ctx,
-		cancel:       cancel,
-	}
-
-	metricsAggregator = aggregator
-
-	// Start publishing metrics
-	go aggregator.startPublishing()
-
-	if logger != nil {
-		logger.Info(&libpack_logger.LogMessage{
-			Message: "Metrics aggregator initialized",
-			Pairs: map[string]interface{}{
-				"instance_id": instanceID,
-				"redis_url":   redisURL,
-				"publish_key": aggregator.publishKey,
-			},
-		})
-	}
-
-	return nil
-}
-
-// GetMetricsAggregator returns the singleton instance
-func GetMetricsAggregator() *MetricsAggregator {
-	aggregatorMutex.RLock()
-	defer aggregatorMutex.RUnlock()
-	return metricsAggregator
-}
-
-// startPublishing periodically publishes metrics to Redis
-func (ma *MetricsAggregator) startPublishing() {
-	defer ma.publishTimer.Stop()
-
-	// Publish immediately on start
-	ma.publishMetrics()
-
-	for {
-		select {
-		case <-ma.ctx.Done():
-			// Clean up our metrics on shutdown
-			ma.removeInstanceMetrics()
-			return
-		case <-ma.publishTimer.C:
-			ma.publishMetrics()
-		}
-	}
-}
-
-// publishMetrics collects current metrics and stores them in Redis
-// Note: This is exported for testing/debugging via admin API
-func (ma *MetricsAggregator) publishMetrics() {
-	// Defensive: check if aggregator is still valid
-	if ma == nil {
-		return
-	}
-
-	ma.mu.RLock()
-	defer ma.mu.RUnlock()
-
-	// Safety check: ensure global config is initialized
-	if cfg == nil {
-		if ma.logger != nil {
-			ma.logger.Warning(&libpack_logger.LogMessage{
-				Message: "Cannot publish metrics - global config not initialized yet",
-				Pairs: map[string]interface{}{
-					"instance_id": ma.instanceID,
-				},
-			})
-		}
-		return
-	}
-
-	// Gather all stats using the admin dashboard's method
-	dashboard := NewAdminDashboard(ma.logger)
-	allStats := dashboard.gatherAllStats()
-
-	if len(allStats) == 0 {
-		if ma.logger != nil {
-			ma.logger.Warning(&libpack_logger.LogMessage{
-				Message: "gatherAllStats returned empty/nil result",
-				Pairs: map[string]interface{}{
-					"instance_id": ma.instanceID,
-				},
-			})
-		}
-		return
-	}
-
-	// Create instance metrics
-	hostname, _ := os.Hostname()
-	if hostname == "" {
-		hostname = "unknown"
-	}
-
-	metrics := InstanceMetrics{
-		InstanceID:    ma.instanceID,
-		Hostname:      hostname,
-		LastUpdate:    time.Now(),
-		UptimeSeconds: time.Since(startTime).Seconds(),
-	}
-
-	// Extract specific sections - CRITICAL: we must set the correct structure
-	// Stats should contain the inner stats object with requests, cache_summary, etc.
-	if stats, ok := allStats["stats"].(map[string]interface{}); ok {
-		metrics.Stats = stats
-
-		// Also extract cache summary separately for easier access (deprecated but kept for compatibility)
-		if cacheSummary, ok := stats["cache_summary"].(map[string]interface{}); ok {
-			metrics.CacheSummary = cacheSummary
-		}
-
-	} else {
-		// Fallback: if stats extraction fails, use empty map
-		if ma.logger != nil {
-			ma.logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to extract stats from allStats - using empty stats",
-				Pairs: map[string]interface{}{
-					"instance_id": ma.instanceID,
-					"allStats_keys": func() []string {
-						keys := make([]string, 0, len(allStats))
-						for k := range allStats {
-							keys = append(keys, k)
-						}
-						return keys
-					}(),
-				},
-			})
-		}
-		metrics.Stats = make(map[string]interface{})
-	}
-
-	// Extract full cache details (includes memory usage)
-	if cache, ok := allStats["cache"].(map[string]interface{}); ok {
-		metrics.Cache = cache
-	}
-
-	if health, ok := allStats["health"].(map[string]interface{}); ok {
-		metrics.Health = health
-	} else {
-		metrics.Health = make(map[string]interface{})
-	}
-	if cb, ok := allStats["circuit_breaker"].(map[string]interface{}); ok {
-		metrics.CircuitBreaker = cb
-	}
-	if rb, ok := allStats["retry_budget"].(map[string]interface{}); ok {
-		metrics.RetryBudget = rb
-	}
-	if coal, ok := allStats["coalescing"].(map[string]interface{}); ok {
-		metrics.Coalescing = coal
-	}
-	if ws, ok := allStats["websocket"].(map[string]interface{}); ok {
-		metrics.WebSocketStats = ws
-	}
-	if conn, ok := allStats["connections"].(map[string]interface{}); ok {
-		metrics.Connections = conn
-	}
-
-	// Marshal to JSON
-	data, err := json.Marshal(metrics)
-	if err != nil {
-		if ma.logger != nil {
-			ma.logger.Error(&libpack_logger.LogMessage{
-				Message: "Failed to marshal metrics for Redis",
-				Pairs:   map[string]interface{}{"error": err.Error()},
-			})
-		}
-		return
-	}
-
-	// Store in Redis hash with TTL
-	key := fmt.Sprintf("%s:%s", ma.publishKey, ma.instanceID)
-
-	// Create a fresh context with timeout to avoid inheriting cancelled parent context
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-
-	pipe := ma.redisClient.Pipeline()
-	pipe.Set(ctx, key, data, ma.ttl)
-	pipe.SAdd(ctx, ma.publishKey, ma.instanceID)
-	pipe.Expire(ctx, ma.publishKey, ma.ttl*2) // Keep set alive
-
-	_, err = pipe.Exec(ctx)
-	if err != nil {
-		if ma.logger != nil {
-			ma.logger.Error(&libpack_logger.LogMessage{
-				Message: "❌ CRITICAL: Failed to publish metrics to Redis - cluster mode will not work!",
-				Pairs: map[string]interface{}{
-					"error":       err.Error(),
-					"instance_id": ma.instanceID,
-					"key":         key,
-					"redis_key":   ma.publishKey,
-				},
-			})
-		}
-		return
-	}
-}
-
-// removeInstanceMetrics cleans up metrics from Redis on shutdown
-func (ma *MetricsAggregator) removeInstanceMetrics() {
-	// Create a fresh context with timeout for cleanup
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-
-	key := fmt.Sprintf("%s:%s", ma.publishKey, ma.instanceID)
-	pipe := ma.redisClient.Pipeline()
-	pipe.Del(ctx, key)
-	pipe.SRem(ctx, ma.publishKey, ma.instanceID)
-	_, err := pipe.Exec(ctx)
-
-	if err != nil && ma.logger != nil {
-		ma.logger.Warning(&libpack_logger.LogMessage{
-			Message: "Failed to remove instance metrics from Redis during shutdown",
-			Pairs:   map[string]interface{}{"instance_id": ma.instanceID, "error": err.Error()},
-		})
-		return
-	}
-
-	if ma.logger != nil {
-		ma.logger.Info(&libpack_logger.LogMessage{
-			Message: "Removed instance metrics from Redis",
-			Pairs:   map[string]interface{}{"instance_id": ma.instanceID},
-		})
-	}
-}
-
-// GetAggregatedMetrics retrieves and aggregates metrics from all instances
-func (ma *MetricsAggregator) GetAggregatedMetrics() (*AggregatedMetrics, error) {
-	// Create a fresh context with timeout to avoid inheriting cancelled parent context
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
-
-	// Get all instance IDs
-	instanceIDs, err := ma.redisClient.SMembers(ctx, ma.publishKey).Result()
-	if err != nil {
-		return nil, fmt.Errorf("failed to get instance list: %w", err)
-	}
-
-	if len(instanceIDs) == 0 {
-		return &AggregatedMetrics{
-			TotalInstances:   0,
-			HealthyInstances: 0,
-			LastUpdate:       time.Now(),
-			CombinedStats:    make(map[string]interface{}),
-			Instances:        []InstanceMetrics{},
-			PerInstanceStats: make(map[string]InstanceMetrics),
-		}, nil
-	}
-
-	// Fetch metrics for all instances
-	pipe := ma.redisClient.Pipeline()
-	cmds := make([]*redis.StringCmd, len(instanceIDs))
-	for i, instanceID := range instanceIDs {
-		key := fmt.Sprintf("%s:%s", ma.publishKey, instanceID)
-		cmds[i] = pipe.Get(ctx, key)
-	}
-	pipe.Exec(ctx)
-
-	// Parse metrics
-	instances := make([]InstanceMetrics, 0, len(instanceIDs))
-	perInstance := make(map[string]InstanceMetrics)
-	healthyCount := 0
-	staleCount := 0
-	errorCount := 0
-
-	for i, cmd := range cmds {
-		data, err := cmd.Result()
-		if err != nil {
-			errorCount++
-			// Clean up stale instance ID from the set
-			if err == redis.Nil {
-				staleCount++
-				// Remove stale instance from set in background
-				go func(instID string) {
-					cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 2*time.Second)
-					defer cleanupCancel()
-					ma.redisClient.SRem(cleanupCtx, ma.publishKey, instID)
-				}(instanceIDs[i])
-			}
-			continue
-		}
-
-		var metrics InstanceMetrics
-		if err := json.Unmarshal([]byte(data), &metrics); err != nil {
-			if ma.logger != nil {
-				ma.logger.Warning(&libpack_logger.LogMessage{
-					Message: "Failed to unmarshal instance metrics",
-					Pairs:   map[string]interface{}{"error": err.Error()},
-				})
-			}
-			continue
-		}
-
-		// Check if instance is stale (not updated in 1 minute)
-		instanceAge := time.Since(metrics.LastUpdate)
-		if instanceAge > 1*time.Minute {
-			staleCount++
-			// Clean up stale instance from set in background
-			go func(instID string, age time.Duration) {
-				cleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 2*time.Second)
-				defer cleanupCancel()
-				ma.redisClient.SRem(cleanupCtx, ma.publishKey, instID)
-				if ma.logger != nil {
-					ma.logger.Info(&libpack_logger.LogMessage{
-						Message: "Removed inactive instance",
-						Pairs: map[string]interface{}{
-							"instance_id":      instID,
-							"inactive_seconds": age.Seconds(),
-						},
-					})
-				}
-			}(instanceIDs[i], instanceAge)
-			continue // Skip stale instances
-		}
-
-		instances = append(instances, metrics)
-		perInstance[metrics.InstanceID] = metrics
-
-		// Count healthy instances
-		if health, ok := metrics.Health["status"].(string); ok && health == "healthy" {
-			healthyCount++
-		}
-	}
-
-	// Log cleanup stats if we found stale instances
-	if ma.logger != nil && (staleCount > 0 || errorCount > 0) {
-		ma.logger.Info(&libpack_logger.LogMessage{
-			Message: "Cleaned up stale instance IDs from Redis",
-			Pairs: map[string]interface{}{
-				"total_in_set":    len(instanceIDs),
-				"valid_instances": len(instances),
-				"stale_cleaned":   staleCount,
-				"errors":          errorCount,
-			},
-		})
-	}
-
-	// Aggregate statistics
-	aggregated := &AggregatedMetrics{
-		TotalInstances:   len(instances),
-		HealthyInstances: healthyCount,
-		LastUpdate:       time.Now(),
-		CombinedStats:    ma.aggregateStats(instances),
-		Instances:        instances,
-		PerInstanceStats: perInstance,
-	}
-
-	return aggregated, nil
-}
-
-// aggregateStats combines statistics from multiple instances
-func (ma *MetricsAggregator) aggregateStats(instances []InstanceMetrics) map[string]interface{} {
-	if len(instances) == 0 {
-		if ma.logger != nil {
-			ma.logger.Warning(&libpack_logger.LogMessage{
-				Message: "No instances to aggregate",
-			})
-		}
-		return make(map[string]interface{})
-	}
-
-	// Initialize aggregated values
-	var (
-		totalRequests          int64
-		totalSucceeded         int64
-		totalFailed            int64
-		totalSkipped           int64
-		totalCacheHits         int64
-		totalCacheMisses       int64
-		totalCachedQueries     int64
-		totalMemoryUsageMB     float64
-		hasValidMemoryStats    bool // Track if any instance has valid memory stats
-		totalCurrentRPS        float64
-		totalAvgRPS            float64
-		totalActiveConnections int64
-		totalWSConnections     int64
-		totalCoalescedRequests int64
-		totalPrimaryRequests   int64
-		oldestUptime           float64
-
-		// Retry budget stats
-		totalRetryAllowed  int64
-		totalRetryDenied   int64
-		totalRetryAttempts int64
-		totalCurrentTokens int64
-		totalMaxTokens     int64
-		retryBudgetEnabled = false
-		retryTokensPerSec  float64 // Use max tokens_per_sec from any instance
-
-		// Circuit breaker stats
-		cbOpenCount           int
-		cbHalfOpenCount       int
-		cbClosedCount         int
-		circuitBreakerEnabled = false
-	)
-
-	for idx, instance := range instances {
-		// Track oldest uptime for cluster uptime
-		if oldestUptime == 0 || instance.UptimeSeconds < oldestUptime {
-			oldestUptime = instance.UptimeSeconds
-		}
-
-		// Aggregate request stats
-		if instance.Stats == nil {
-			if ma.logger != nil {
-				ma.logger.Warning(&libpack_logger.LogMessage{
-					Message: "Instance has nil Stats",
-					Pairs: map[string]interface{}{
-						"instance_id": instance.InstanceID,
-						"index":       idx,
-					},
-				})
-			}
-			continue
-		}
-
-		if stats, ok := instance.Stats["requests"].(map[string]interface{}); ok {
-			if total, ok := stats["total"].(float64); ok {
-				totalRequests += int64(total)
-			}
-			if succeeded, ok := stats["succeeded"].(float64); ok {
-				totalSucceeded += int64(succeeded)
-			}
-			if failed, ok := stats["failed"].(float64); ok {
-				totalFailed += int64(failed)
-			}
-			if skipped, ok := stats["skipped"].(float64); ok {
-				totalSkipped += int64(skipped)
-			}
-			if currentRPS, ok := stats["current_requests_per_second"].(float64); ok {
-				totalCurrentRPS += currentRPS
-			}
-			if avgRPS, ok := stats["avg_requests_per_second"].(float64); ok {
-				totalAvgRPS += avgRPS
-			}
-		} else {
-			if ma.logger != nil {
-				// Log what keys are actually in Stats for debugging
-				keys := make([]string, 0, len(instance.Stats))
-				for k := range instance.Stats {
-					keys = append(keys, k)
-				}
-				ma.logger.Warning(&libpack_logger.LogMessage{
-					Message: "Instance Stats missing 'requests' key",
-					Pairs: map[string]interface{}{
-						"instance_id": instance.InstanceID,
-						"stats_keys":  keys,
-						"index":       idx,
-					},
-				})
-			}
-		}
-
-		// Aggregate cache stats from CacheSummary (backward compatibility)
-		if len(instance.CacheSummary) > 0 {
-			if hits, ok := instance.CacheSummary["hits"].(float64); ok {
-				totalCacheHits += int64(hits)
-			}
-			if misses, ok := instance.CacheSummary["misses"].(float64); ok {
-				totalCacheMisses += int64(misses)
-			}
-			if cached, ok := instance.CacheSummary["total_cached"].(float64); ok {
-				totalCachedQueries += int64(cached)
-			}
-		}
-
-		// Aggregate memory usage from full cache details
-		// Skip -1 values which indicate Redis cache (memory tracking not available)
-		if len(instance.Cache) > 0 {
-			if memMB, ok := instance.Cache["memory_usage_mb"].(float64); ok && memMB >= 0 {
-				totalMemoryUsageMB += memMB
-				hasValidMemoryStats = true
-			}
-		}
-
-		// Aggregate connection stats
-		if len(instance.Connections) > 0 {
-			if active, ok := instance.Connections["active_connections"].(float64); ok {
-				totalActiveConnections += int64(active)
-			}
-		}
-
-		// Aggregate WebSocket connections
-		if len(instance.WebSocketStats) > 0 {
-			if active, ok := instance.WebSocketStats["active_connections"].(float64); ok {
-				totalWSConnections += int64(active)
-			}
-		}
-
-		// Aggregate coalescing stats
-		if len(instance.Coalescing) > 0 {
-			if coalesced, ok := instance.Coalescing["coalesced_requests"].(float64); ok {
-				totalCoalescedRequests += int64(coalesced)
-			}
-			if primary, ok := instance.Coalescing["primary_requests"].(float64); ok {
-				totalPrimaryRequests += int64(primary)
-			}
-		}
-
-		// Aggregate retry budget stats
-		if len(instance.RetryBudget) > 0 {
-			if enabled, ok := instance.RetryBudget["enabled"].(bool); ok && enabled {
-				retryBudgetEnabled = true
-			}
-			if allowed, ok := instance.RetryBudget["allowed_retries"].(float64); ok {
-				totalRetryAllowed += int64(allowed)
-			}
-			if denied, ok := instance.RetryBudget["denied_retries"].(float64); ok {
-				totalRetryDenied += int64(denied)
-			}
-			if attempts, ok := instance.RetryBudget["total_attempts"].(float64); ok {
-				totalRetryAttempts += int64(attempts)
-			}
-			if currentTokens, ok := instance.RetryBudget["current_tokens"].(float64); ok {
-				totalCurrentTokens += int64(currentTokens)
-			}
-			if maxTokens, ok := instance.RetryBudget["max_tokens"].(float64); ok {
-				totalMaxTokens += int64(maxTokens)
-			}
-			if tokensPerSec, ok := instance.RetryBudget["tokens_per_sec"].(float64); ok {
-				if tokensPerSec > retryTokensPerSec {
-					retryTokensPerSec = tokensPerSec
-				}
-			}
-		}
-
-		// Aggregate circuit breaker stats
-		if len(instance.CircuitBreaker) > 0 {
-			if enabled, ok := instance.CircuitBreaker["enabled"].(bool); ok && enabled {
-				circuitBreakerEnabled = true
-			}
-			if state, ok := instance.CircuitBreaker["state"].(string); ok {
-				switch state {
-				case "open":
-					cbOpenCount++
-				case "half-open":
-					cbHalfOpenCount++
-				case "closed":
-					cbClosedCount++
-				}
-			}
-		}
-	}
-
-	// Calculate derived metrics
-	successRate := 0.0
-	if totalRequests > 0 {
-		successRate = float64(totalSucceeded) / float64(totalRequests) * 100
-	}
-
-	cacheHitRate := 0.0
-	totalCacheRequests := totalCacheHits + totalCacheMisses
-	if totalCacheRequests > 0 {
-		cacheHitRate = float64(totalCacheHits) / float64(totalCacheRequests) * 100
-	}
-
-	backendSavings := 0.0
-	totalCoalRequests := totalCoalescedRequests + totalPrimaryRequests
-	if totalCoalRequests > 0 {
-		backendSavings = float64(totalCoalescedRequests) / float64(totalCoalRequests) * 100
-	}
-
-	// Calculate retry budget denial rate
-	retryDenialRate := 0.0
-	if totalRetryAttempts > 0 {
-		retryDenialRate = float64(totalRetryDenied) / float64(totalRetryAttempts) * 100
-	}
-
-	// Determine overall circuit breaker state
-	cbState := "unknown"
-	if circuitBreakerEnabled {
-		if cbOpenCount > 0 {
-			cbState = "open" // If any instance is open, cluster is in degraded state
-		} else if cbHalfOpenCount > 0 {
-			cbState = "half-open"
-		} else if cbClosedCount > 0 {
-			cbState = "closed"
-		}
-	}
-
-	result := map[string]interface{}{
-		"cluster_mode":    true,
-		"total_instances": len(instances),
-		"cluster_uptime":  oldestUptime,
-		"requests": map[string]interface{}{
-			"total":                       totalRequests,
-			"succeeded":                   totalSucceeded,
-			"failed":                      totalFailed,
-			"skipped":                     totalSkipped,
-			"success_rate_pct":            successRate,
-			"current_requests_per_second": totalCurrentRPS,
-			"avg_requests_per_second":     totalAvgRPS,
-		},
-		"cache_summary": map[string]interface{}{
-			"hits":         totalCacheHits,
-			"misses":       totalCacheMisses,
-			"hit_rate_pct": cacheHitRate,
-			"total_cached": totalCachedQueries,
-		},
-		"memory": map[string]interface{}{
-			"total_usage_mb": func() float64 {
-				if hasValidMemoryStats {
-					return totalMemoryUsageMB
-				}
-				return -1
-			}(),
-			"available": hasValidMemoryStats,
-		},
-		"connections": map[string]interface{}{
-			"total_active": totalActiveConnections,
-		},
-		"websocket": map[string]interface{}{
-			"total_connections": totalWSConnections,
-		},
-		"coalescing": map[string]interface{}{
-			"enabled":                  len(instances) > 0, // enabled if we have instances with data
-			"total_coalesced_requests": totalCoalescedRequests,
-			"total_primary_requests":   totalPrimaryRequests,
-			"backend_savings_pct":      backendSavings,
-			"coalescing_rate_pct":      backendSavings,
-		},
-		"retry_budget": map[string]interface{}{
-			"enabled":         retryBudgetEnabled,
-			"allowed_retries": totalRetryAllowed,
-			"denied_retries":  totalRetryDenied,
-			"total_attempts":  totalRetryAttempts,
-			"denial_rate_pct": retryDenialRate,
-			"current_tokens":  totalCurrentTokens,
-			"max_tokens":      totalMaxTokens,
-			"tokens_per_sec":  retryTokensPerSec,
-		},
-		"circuit_breaker": map[string]interface{}{
-			"enabled":            circuitBreakerEnabled,
-			"state":              cbState,
-			"instances_open":     cbOpenCount,
-			"instances_closed":   cbClosedCount,
-			"instances_halfopen": cbHalfOpenCount,
-		},
-	}
-
-	return result
-}
-
-// Shutdown stops the metrics aggregator
-func (ma *MetricsAggregator) Shutdown() {
-	ma.mu.Lock()
-	defer ma.mu.Unlock()
-
-	if ma.cancel != nil {
-		ma.cancel()
-	}
-
-	if ma.redisClient != nil {
-		ma.redisClient.Close()
-	}
-
-	if ma.logger != nil {
-		ma.logger.Info(&libpack_logger.LogMessage{
-			Message: "Metrics aggregator shut down",
-		})
-	}
-}
-
-// GetInstanceID returns the current instance ID
-func (ma *MetricsAggregator) GetInstanceID() string {
-	return ma.instanceID
-}
-
-// IsClusterMode returns true if multiple instances are detected
-func (ma *MetricsAggregator) IsClusterMode() bool {
-	// Create a fresh context with timeout to avoid inheriting cancelled parent context
-	ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
-	defer cancel()
-
-	count, err := ma.redisClient.SCard(ctx, ma.publishKey).Result()
-	if err != nil {
-		return false
-	}
-
-	return count > 1
-}
-
-// GetInstanceHostname returns a human-readable instance identifier
-func GetInstanceHostname() string {
-	hostname, _ := os.Hostname()
-	if hostname == "" {
-		hostname = "unknown"
-	}
-	// Remove domain suffix for cleaner display
-	if idx := strings.Index(hostname, "."); idx > 0 {
-		hostname = hostname[:idx]
-	}
-	return hostname
-}

monitoring.go

@@ -5,15 +5,11 @@ import (
 )
 
 // StartMonitoringServer initializes and starts the monitoring server.
-func StartMonitoringServer() error {
+func StartMonitoringServer() {
 	cfg.Monitoring = libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{
 		PurgeOnCrawl: cfg.Server.PurgeOnCrawl,
 		PurgeEvery:   cfg.Server.PurgeEvery,
 	})
 	cfg.Monitoring.AddMetricsPrefix("graphql_proxy")
 	cfg.Monitoring.RegisterDefaultMetrics()
-
-	// Currently, the monitoring server initialization doesn't throw errors,
-	// but we return nil to maintain the interface contract
-	return nil
 }

monitoring/defaults.go

@@ -9,3 +9,7 @@ func (ms *MetricsSetup) RegisterDefaultMetrics() {
 	ms.RegisterMetricsCounter(MetricsCacheMiss, nil)
 	ms.RegisterMetricsCounter(MetricsQueriesCached, nil)
 }
+
+func (ms *MetricsSetup) RegisterGoMetrics() {
+	// TODO: metrics.WriteProcessMetrics(ms.metrics_set)
+}

monitoring/helpers.go

@@ -68,82 +68,20 @@ func ensureDefaultLabels(labels *map[string]string, podName string) {
 	}
 }
 
-// sanitizeLabelValue removes or replaces characters that are invalid in metric labels
-// This includes null bytes, newlines, carriage returns, quotes, and backslashes
-func sanitizeLabelValue(value string) string {
-	if value == "" {
-		return value
-	}
-
-	var buf strings.Builder
-	buf.Grow(len(value))
-
-	for _, r := range value {
-		switch r {
-		case '\x00': // null byte
-			continue // Skip null bytes entirely
-		case '\n', '\r', '\t': // newlines, carriage returns, tabs
-			buf.WriteByte(' ') // Replace with space
-		case '"', '\\': // quotes and backslashes need escaping
-			buf.WriteByte('\\')
-			buf.WriteRune(r)
-		default:
-			// Only allow printable ASCII and common unicode characters
-			if unicode.IsPrint(r) {
-				buf.WriteRune(r)
-			}
-		}
-	}
-
-	return buf.String()
-}
-
 func appendSortedLabels(buf *bytes.Buffer, labels map[string]string) {
-	// Add defer/recover to prevent panics from crashing the application
-	defer func() {
-		if r := recover(); r != nil {
-			// Log the panic but don't crash
-			fmt.Fprintf(os.Stderr, "Recovered from panic in appendSortedLabels: %v\n", r)
-		}
-	}()
-
-	if len(labels) == 0 || buf == nil {
-		return
-	}
-
-	// Create a snapshot to avoid concurrent access issues
-	labelsCopy := make(map[string]string, len(labels))
-	for k, v := range labels {
-		if k == "" {
-			continue // Skip empty keys
-		}
-		// Sanitize the label value to remove null bytes and other invalid characters
-		labelsCopy[k] = sanitizeLabelValue(v)
-	}
-
-	if len(labelsCopy) == 0 {
-		return
-	}
-
-	keys := getSortedKeys(labelsCopy)
+	keys := getSortedKeys(labels)
 	for i, k := range keys {
-		if v, ok := labelsCopy[k]; ok {
-			if i > 0 {
-				buf.WriteByte(',')
-			}
-			buf.WriteString(k)
-			buf.WriteString(`="`)
-			buf.WriteString(v)
-			buf.WriteByte('"')
+		if i > 0 {
+			buf.WriteByte(',')
 		}
+		buf.WriteString(k)
+		buf.WriteString(`="`)
+		buf.WriteString(labels[k])
+		buf.WriteByte('"')
 	}
 }
 
 func getSortedKeys(labels map[string]string) []string {
-	if labels == nil {
-		return []string{}
-	}
-
 	labelsKey := labelsToString(labels)
 
 	// Check if the sorted keys are already cached
@@ -151,7 +89,7 @@ func getSortedKeys(labels map[string]string) []string {
 		return keys.([]string)
 	}
 
-	// Compute the sorted keys - create a snapshot to avoid concurrent access issues
+	// Compute the sorted keys
 	keys := make([]string, 0, len(labels))
 	for k := range labels {
 		keys = append(keys, k)
@@ -165,51 +103,18 @@ func getSortedKeys(labels map[string]string) []string {
 }
 
 func labelsToString(labels map[string]string) string {
-	// Add defer/recover to prevent panics from crashing the application
-	defer func() {
-		if r := recover(); r != nil {
-			// Log the panic but don't crash
-			fmt.Fprintf(os.Stderr, "Recovered from panic in labelsToString: %v\n", r)
-		}
-	}()
-
-	if len(labels) == 0 {
-		return ""
-	}
-
-	// Create a snapshot of the map to avoid concurrent access issues
 	keys := make([]string, 0, len(labels))
-	values := make(map[string]string, len(labels))
-
-	for k, v := range labels {
-		if k == "" {
-			continue // Skip empty keys
-		}
+	for k := range labels {
 		keys = append(keys, k)
-		values[k] = v
 	}
-
-	if len(keys) == 0 {
-		return ""
-	}
-
 	sort.Strings(keys)
 
-	// Pre-allocate the builder with estimated capacity to avoid reallocation
 	var sb strings.Builder
-	estimatedSize := 0
 	for _, k := range keys {
-		estimatedSize += len(k) + len(values[k]) + 2 // key + value + '=' + ';'
-	}
-	sb.Grow(estimatedSize)
-
-	for _, k := range keys {
-		if v, ok := values[k]; ok {
-			sb.WriteString(k)
-			sb.WriteByte('=')
-			sb.WriteString(v)
-			sb.WriteByte(';')
-		}
+		sb.WriteString(k)
+		sb.WriteByte('=')
+		sb.WriteString(labels[k])
+		sb.WriteByte(';')
 	}
 	return sb.String()
 }
@@ -259,44 +164,17 @@ func is_special_rune(r rune) bool {
 }
 
 func compile_metrics_with_labels(name string, labels map[string]string) string {
-	// Add defer/recover to prevent panics from crashing the application
-	defer func() {
-		if r := recover(); r != nil {
-			// Log the panic but don't crash
-			fmt.Fprintf(os.Stderr, "Recovered from panic in compile_metrics_with_labels: %v\n", r)
-		}
-	}()
-
 	var buf bytes.Buffer
 
 	buf.WriteString(name)
 
-	if len(labels) == 0 {
-		return buf.String()
-	}
-
-	// Create a snapshot to avoid concurrent access issues
-	labelsCopy := make(map[string]string, len(labels))
-	for k, v := range labels {
-		if k == "" {
-			continue // Skip empty keys
-		}
-		labelsCopy[k] = v
-	}
-
-	if len(labelsCopy) == 0 {
-		return buf.String()
-	}
-
-	keys := getSortedKeys(labelsCopy)
+	keys := getSortedKeys(labels)
 
 	for _, k := range keys {
-		if v, ok := labelsCopy[k]; ok {
-			buf.WriteByte('_')
-			buf.WriteString(k)
-			buf.WriteByte('_')
-			buf.WriteString(v)
-		}
+		buf.WriteByte('_')
+		buf.WriteString(k)
+		buf.WriteByte('_')
+		buf.WriteString(labels[k])
 	}
 
 	return buf.String()

monitoring/helpers_bench_test.go

@@ -39,6 +39,6 @@ func BenchmarkValidateMetricsName(b *testing.B) {
 	input := "valid metric name with special chars @#! and underscores__"
 
 	for n := 0; n < b.N; n++ {
-		_ = validate_metrics_name(input)
+		validate_metrics_name(input)
 	}
 }

monitoring/monitoring.go

@@ -1,7 +1,6 @@
 package libpack_monitoring
 
 import (
-	"context"
 	"flag"
 	"fmt"
 	"time"
@@ -18,8 +17,6 @@ type MetricsSetup struct {
 	metrics_set_custom *metrics.Set
 	ic                 *InitConfig
 	metrics_prefix     string
-	ctx                context.Context
-	cancel             context.CancelFunc
 }
 
 var log = libpack_logger.New().SetMinLogLevel(libpack_logger.LEVEL_INFO)
@@ -30,18 +27,10 @@ type InitConfig struct {
 }
 
 func NewMonitoring(ic *InitConfig) *MetricsSetup {
-	return NewMonitoringWithContext(context.Background(), ic)
-}
-
-// NewMonitoringWithContext creates a new monitoring instance with context for graceful shutdown
-func NewMonitoringWithContext(ctx context.Context, ic *InitConfig) *MetricsSetup {
-	monCtx, cancel := context.WithCancel(ctx)
 	ms := &MetricsSetup{
 		ic:                 ic,
 		metrics_set:        metrics.NewSet(),
 		metrics_set_custom: metrics.NewSet(),
-		ctx:                monCtx,
-		cancel:             cancel,
 	}
 
 	if flag.Lookup("test.v") == nil {
@@ -50,14 +39,8 @@ func NewMonitoringWithContext(ctx context.Context, ic *InitConfig) *MetricsSetup
 		if ic.PurgeEvery > 0 {
 			ticker := time.NewTicker(time.Duration(ic.PurgeEvery) * time.Second)
 			go func() {
-				defer ticker.Stop()
-				for {
-					select {
-					case <-ms.ctx.Done():
-						return
-					case <-ticker.C:
-						ms.PurgeMetrics()
-					}
+				for range ticker.C {
+					ms.PurgeMetrics()
 				}
 			}()
 		}
@@ -66,13 +49,6 @@ func NewMonitoringWithContext(ctx context.Context, ic *InitConfig) *MetricsSetup
 	return ms
 }
 
-// Shutdown stops the monitoring goroutines
-func (ms *MetricsSetup) Shutdown() {
-	if ms.cancel != nil {
-		ms.cancel()
-	}
-}
-
 func (ms *MetricsSetup) startPrometheusEndpoint() {
 	app := fiber.New(fiber.Config{
 		DisableStartupMessage: true,
@@ -81,7 +57,7 @@ func (ms *MetricsSetup) startPrometheusEndpoint() {
 	app.Get("/metrics", ms.metricsEndpoint)
 	if err := app.Listen(fmt.Sprintf(":%d", envutil.GetInt("MONITORING_PORT", 9393))); err != nil {
 		log.Critical(&libpack_logger.LogMessage{
-			Message: "Can't start the MONITORING service",
+			Message: "Can't start the service",
 			Pairs:   map[string]interface{}{"error": err},
 		})
 	}
@@ -107,40 +83,24 @@ func (ms *MetricsSetup) ListActiveMetrics() []string {
 
 func (ms *MetricsSetup) RegisterMetricsGauge(metric_name string, labels map[string]string, val float64) *metrics.Gauge {
 	if err := validate_metrics_name(metric_name); err != nil {
-		log.Error(&libpack_logger.LogMessage{
-			Message: "RegisterMetricsGauge() error - invalid metric name",
-			Pairs:   map[string]interface{}{"error": err.Error(), "metric_name": metric_name},
+		log.Critical(&libpack_logger.LogMessage{
+			Message: "RegisterMetricsGauge() error",
+			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
 		})
-		// Return a dummy gauge instead of nil to prevent panics
-		return &metrics.Gauge{}
+		return nil
 	}
 	return ms.metrics_set_custom.GetOrCreateGauge(ms.get_metrics_name(metric_name, labels), func() float64 {
 		return val
 	})
 }
 
-// RegisterMetricsGaugeFunc registers a gauge with a callback function that is called on every scrape
-// This is useful for metrics that need to return a dynamic value
-func (ms *MetricsSetup) RegisterMetricsGaugeFunc(metric_name string, labels map[string]string, fn func() float64) *metrics.Gauge {
-	if err := validate_metrics_name(metric_name); err != nil {
-		log.Error(&libpack_logger.LogMessage{
-			Message: "RegisterMetricsGaugeFunc() error - invalid metric name",
-			Pairs:   map[string]interface{}{"error": err.Error(), "metric_name": metric_name},
-		})
-		// Return a dummy gauge instead of nil to prevent panics
-		return &metrics.Gauge{}
-	}
-	return ms.metrics_set_custom.GetOrCreateGauge(ms.get_metrics_name(metric_name, labels), fn)
-}
-
 func (ms *MetricsSetup) RegisterMetricsCounter(metric_name string, labels map[string]string) *metrics.Counter {
 	if err := validate_metrics_name(metric_name); err != nil {
-		log.Error(&libpack_logger.LogMessage{
-			Message: "RegisterMetricsCounter() error - invalid metric name",
-			Pairs:   map[string]interface{}{"error": err.Error(), "metric_name": metric_name},
+		log.Critical(&libpack_logger.LogMessage{
+			Message: "RegisterMetricsCounter() error",
+			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
 		})
-		// Return a dummy counter instead of nil to prevent panics
-		return &metrics.Counter{}
+		return nil
 	}
 	if metric_name == MetricsSucceeded || metric_name == MetricsFailed || metric_name == MetricsSkipped {
 		return ms.metrics_set.GetOrCreateCounter(ms.get_metrics_name(metric_name, labels))
@@ -150,36 +110,33 @@ func (ms *MetricsSetup) RegisterMetricsCounter(metric_name string, labels map[st
 
 func (ms *MetricsSetup) RegisterFloatCounter(metric_name string, labels map[string]string) *metrics.FloatCounter {
 	if err := validate_metrics_name(metric_name); err != nil {
-		log.Error(&libpack_logger.LogMessage{
-			Message: "RegisterFloatCounter() error - invalid metric name",
-			Pairs:   map[string]interface{}{"error": err.Error(), "metric_name": metric_name},
+		log.Critical(&libpack_logger.LogMessage{
+			Message: "RegisterFloatCounter() error",
+			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
 		})
-		// Return a dummy float counter instead of nil to prevent panics
-		return &metrics.FloatCounter{}
+		return nil
 	}
 	return ms.metrics_set_custom.GetOrCreateFloatCounter(ms.get_metrics_name(metric_name, labels))
 }
 
 func (ms *MetricsSetup) RegisterMetricsSummary(metric_name string, labels map[string]string) *metrics.Summary {
 	if err := validate_metrics_name(metric_name); err != nil {
-		log.Error(&libpack_logger.LogMessage{
-			Message: "RegisterMetricsSummary() error - invalid metric name",
-			Pairs:   map[string]interface{}{"error": err.Error(), "metric_name": metric_name},
+		log.Critical(&libpack_logger.LogMessage{
+			Message: "RegisterMetricsSummary() error",
+			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
 		})
-		// Return a dummy summary instead of nil to prevent panics
-		return &metrics.Summary{}
+		return nil
 	}
 	return ms.metrics_set_custom.GetOrCreateSummary(ms.get_metrics_name(metric_name, labels))
 }
 
 func (ms *MetricsSetup) RegisterMetricsHistogram(metric_name string, labels map[string]string) *metrics.Histogram {
 	if err := validate_metrics_name(metric_name); err != nil {
-		log.Error(&libpack_logger.LogMessage{
-			Message: "RegisterMetricsHistogram() error - invalid metric name",
-			Pairs:   map[string]interface{}{"error": err.Error(), "metric_name": metric_name},
+		log.Critical(&libpack_logger.LogMessage{
+			Message: "RegisterMetricsHistogram() error",
+			Pairs:   map[string]interface{}{"_error": "Invalid metric name", "_metric_name": metric_name},
 		})
-		// Return a dummy histogram instead of nil to prevent panics
-		return &metrics.Histogram{}
+		return nil
 	}
 	return ms.metrics_set_custom.GetOrCreateHistogram(ms.get_metrics_name(metric_name, labels))
 }

monitoring/monitoring_additional_test.go

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

monitoring/monitoring_test.go

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

monitoring/structs.go

@@ -11,32 +11,4 @@ const (
 	MetricsCacheHit      = "cache_hit"
 	MetricsCacheMiss     = "cache_miss"
 	MetricsQueriesCached = "cached_queries"
-
-	// Memory cache metrics
-	MetricsCacheMemoryUsage   = "cache_memory_usage_bytes"
-	MetricsCacheMemoryLimit   = "cache_memory_limit_bytes"
-	MetricsCacheMemoryPercent = "cache_memory_percent_used"
-
-	// GraphQL parsing metrics
-	MetricsGraphQLParsingTime   = "graphql_parsing_time_ms"
-	MetricsGraphQLParsingErrors = "graphql_parsing_errors"
-	MetricsGraphQLCacheHit      = "graphql_parse_cache_hit"
-	MetricsGraphQLCacheMiss     = "graphql_parse_cache_miss"
-	MetricsGraphQLParsingAllocs = "graphql_parsing_allocations"
-
-	// Circuit breaker metrics
-	MetricsCircuitState               = "circuit_state" // 0 = closed, 1 = half-open, 2 = open
-	MetricsCircuitConsecutiveFailures = "circuit_consecutive_failures"
-	MetricsCircuitSuccessful          = "circuit_successful_calls"
-	MetricsCircuitFailed              = "circuit_failed_calls"
-	MetricsCircuitRejected            = "circuit_rejected_calls"
-	MetricsCircuitFallbackSuccess     = "circuit_fallback_success"
-	MetricsCircuitFallbackFailed      = "circuit_fallback_failed"
-)
-
-// Circuit states
-const (
-	CircuitClosed   = 0
-	CircuitHalfOpen = 1
-	CircuitOpen     = 2
 )

pkg/pools/buffer.go

@@ -1,107 +0,0 @@
-package pools
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-	"sync"
-)
-
-const (
-	// MaxBufferSize is the maximum size of a buffer that will be returned to the pool
-	MaxBufferSize = 1024 * 1024 // 1MB
-	// InitialBufferSize is the initial capacity of buffers in the pool
-	InitialBufferSize = 4096 // 4KB
-)
-
-// bufferPool is the global pool for reusable buffers
-var bufferPool = &sync.Pool{
-	New: func() interface{} {
-		return bytes.NewBuffer(make([]byte, 0, InitialBufferSize))
-	},
-}
-
-// gzipWriterPool is the global pool for reusable gzip writers
-var gzipWriterPool = &sync.Pool{
-	New: func() interface{} {
-		return gzip.NewWriter(nil)
-	},
-}
-
-// gzipReaderPool is the global pool for reusable gzip readers
-var gzipReaderPool = &sync.Pool{
-	New: func() interface{} {
-		return new(gzip.Reader)
-	},
-}
-
-// GetBuffer retrieves a buffer from the pool
-func GetBuffer() *bytes.Buffer {
-	buf := bufferPool.Get().(*bytes.Buffer)
-	buf.Reset()
-	return buf
-}
-
-// PutBuffer returns a buffer to the pool
-func PutBuffer(buf *bytes.Buffer) {
-	if buf == nil {
-		return
-	}
-	// Don't pool large buffers to avoid memory bloat
-	if buf.Cap() > MaxBufferSize {
-		return
-	}
-	buf.Reset()
-	bufferPool.Put(buf)
-}
-
-// GetGzipWriter retrieves a gzip writer from the pool
-func GetGzipWriter(w io.Writer) *gzip.Writer {
-	gz := gzipWriterPool.Get().(*gzip.Writer)
-	gz.Reset(w)
-	return gz
-}
-
-// PutGzipWriter returns a gzip writer to the pool
-func PutGzipWriter(gz *gzip.Writer) {
-	if gz == nil {
-		return
-	}
-	gz.Reset(nil)
-	gzipWriterPool.Put(gz)
-}
-
-// GetGzipReader retrieves a gzip reader from the pool
-func GetGzipReader(r io.Reader) (*gzip.Reader, error) {
-	gr := gzipReaderPool.Get().(*gzip.Reader)
-	if err := gr.Reset(r); err != nil {
-		// If reset fails, create a new reader
-		return gzip.NewReader(r)
-	}
-	return gr, nil
-}
-
-// PutGzipReader returns a gzip reader to the pool
-func PutGzipReader(gr *gzip.Reader) {
-	if gr == nil {
-		return
-	}
-	gr.Close()
-	gzipReaderPool.Put(gr)
-}
-
-// Stats provides statistics about the buffer pool usage
-type Stats struct {
-	BuffersInUse  int
-	MaxBufferSize int
-}
-
-// GetStats returns current pool statistics (placeholder for future monitoring)
-func GetStats() Stats {
-	// This is a placeholder for future implementation
-	// sync.Pool doesn't provide direct statistics access
-	return Stats{
-		BuffersInUse:  0,
-		MaxBufferSize: MaxBufferSize,
-	}
-}

pkg/pools/buffer_test.go

@@ -1,417 +0,0 @@
-package pools
-
-import (
-	"bytes"
-	"compress/gzip"
-	"io"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type BufferPoolTestSuite struct {
-	suite.Suite
-}
-
-func TestBufferPoolTestSuite(t *testing.T) {
-	suite.Run(t, new(BufferPoolTestSuite))
-}
-
-func (suite *BufferPoolTestSuite) TestGetBuffer() {
-	buf := GetBuffer()
-	assert.NotNil(suite.T(), buf)
-	assert.Equal(suite.T(), 0, buf.Len())
-	assert.GreaterOrEqual(suite.T(), buf.Cap(), InitialBufferSize)
-}
-
-func (suite *BufferPoolTestSuite) TestPutBuffer() {
-	buf := GetBuffer()
-	buf.WriteString("test data")
-	assert.Equal(suite.T(), "test data", buf.String())
-
-	PutBuffer(buf)
-
-	// Get a new buffer - it should be reset
-	buf2 := GetBuffer()
-	assert.Equal(suite.T(), 0, buf2.Len())
-	assert.Equal(suite.T(), "", buf2.String())
-}
-
-func (suite *BufferPoolTestSuite) TestPutBufferNil() {
-	// Should not panic
-	PutBuffer(nil)
-}
-
-func (suite *BufferPoolTestSuite) TestPutBufferLarge() {
-	buf := bytes.NewBuffer(make([]byte, 0, MaxBufferSize+1))
-
-	// Large buffer should not be pooled
-	PutBuffer(buf)
-
-	// Getting a new buffer should return a new one, not the large one
-	buf2 := GetBuffer()
-	assert.LessOrEqual(suite.T(), buf2.Cap(), MaxBufferSize)
-}
-
-func (suite *BufferPoolTestSuite) TestBufferReuse() {
-	// Test that buffers are actually being reused
-	buf1 := GetBuffer()
-	buf1.WriteString("test")
-	ptr1 := buf1
-
-	PutBuffer(buf1)
-
-	buf2 := GetBuffer()
-	// Due to pool behavior, we might or might not get the same buffer back
-	// but it should be properly reset
-	assert.Equal(suite.T(), 0, buf2.Len())
-	assert.Equal(suite.T(), "", buf2.String())
-	_ = ptr1 // Keep reference to avoid compiler optimization
-}
-
-func (suite *BufferPoolTestSuite) TestGzipWriter() {
-	var buf bytes.Buffer
-	gz := GetGzipWriter(&buf)
-	assert.NotNil(suite.T(), gz)
-
-	// Write some data
-	data := "test gzip data"
-	_, err := gz.Write([]byte(data))
-	assert.NoError(suite.T(), err)
-
-	err = gz.Close()
-	assert.NoError(suite.T(), err)
-
-	// Verify data was compressed
-	assert.Greater(suite.T(), buf.Len(), 0)
-
-	PutGzipWriter(gz)
-}
-
-func (suite *BufferPoolTestSuite) TestGzipWriterNil() {
-	// Should not panic
-	PutGzipWriter(nil)
-}
-
-func (suite *BufferPoolTestSuite) TestGzipWriterReuse() {
-	var buf1, buf2 bytes.Buffer
-
-	// First use
-	gz := GetGzipWriter(&buf1)
-	gz.Write([]byte("data1"))
-	gz.Close()
-	PutGzipWriter(gz)
-
-	// Second use - should be reset
-	gz2 := GetGzipWriter(&buf2)
-	gz2.Write([]byte("data2"))
-	gz2.Close()
-
-	// Both buffers should contain valid gzip data
-	assert.Greater(suite.T(), buf1.Len(), 0)
-	assert.Greater(suite.T(), buf2.Len(), 0)
-	assert.NotEqual(suite.T(), buf1.Bytes(), buf2.Bytes())
-
-	PutGzipWriter(gz2)
-}
-
-func (suite *BufferPoolTestSuite) TestGzipReader() {
-	// Create gzipped data
-	var buf bytes.Buffer
-	gz := gzip.NewWriter(&buf)
-	gz.Write([]byte("test data"))
-	gz.Close()
-
-	// Read using pooled reader
-	gr, err := GetGzipReader(&buf)
-	assert.NoError(suite.T(), err)
-	assert.NotNil(suite.T(), gr)
-
-	data, err := io.ReadAll(gr)
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), "test data", string(data))
-
-	PutGzipReader(gr)
-}
-
-func (suite *BufferPoolTestSuite) TestGzipReaderInvalidData() {
-	buf := bytes.NewBufferString("invalid gzip data")
-
-	gr, err := GetGzipReader(buf)
-	// Should return error or new reader
-	if err == nil {
-		assert.NotNil(suite.T(), gr)
-		// Try to read - should fail
-		_, readErr := io.ReadAll(gr)
-		assert.Error(suite.T(), readErr)
-		PutGzipReader(gr)
-	}
-}
-
-func (suite *BufferPoolTestSuite) TestGzipReaderNil() {
-	// Should not panic
-	PutGzipReader(nil)
-}
-
-func (suite *BufferPoolTestSuite) TestGzipReaderReuse() {
-	// Create two different gzipped data
-	var buf1, buf2 bytes.Buffer
-
-	gz1 := gzip.NewWriter(&buf1)
-	gz1.Write([]byte("data1"))
-	gz1.Close()
-
-	gz2 := gzip.NewWriter(&buf2)
-	gz2.Write([]byte("data2"))
-	gz2.Close()
-
-	// Read first data
-	gr, err := GetGzipReader(&buf1)
-	assert.NoError(suite.T(), err)
-	data1, err := io.ReadAll(gr)
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), "data1", string(data1))
-	PutGzipReader(gr)
-
-	// Read second data with potentially reused reader
-	gr2, err := GetGzipReader(&buf2)
-	assert.NoError(suite.T(), err)
-	data2, err := io.ReadAll(gr2)
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), "data2", string(data2))
-	PutGzipReader(gr2)
-}
-
-func (suite *BufferPoolTestSuite) TestConcurrentBufferAccess() {
-	var wg sync.WaitGroup
-	numGoroutines := 100
-	numOperations := 100
-
-	for i := 0; i < numGoroutines; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			for j := 0; j < numOperations; j++ {
-				buf := GetBuffer()
-				buf.WriteString("test data")
-				assert.Equal(suite.T(), "test data", buf.String())
-				PutBuffer(buf)
-			}
-		}(i)
-	}
-
-	wg.Wait()
-}
-
-func (suite *BufferPoolTestSuite) TestConcurrentGzipWriter() {
-	var wg sync.WaitGroup
-	numGoroutines := 50
-
-	for i := 0; i < numGoroutines; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			var buf bytes.Buffer
-			gz := GetGzipWriter(&buf)
-			data := strings.Repeat("test", 100)
-			gz.Write([]byte(data))
-			gz.Close()
-			assert.Greater(suite.T(), buf.Len(), 0)
-			PutGzipWriter(gz)
-		}(i)
-	}
-
-	wg.Wait()
-}
-
-func (suite *BufferPoolTestSuite) TestConcurrentGzipReader() {
-	// Prepare gzipped data
-	var source bytes.Buffer
-	gz := gzip.NewWriter(&source)
-	gz.Write([]byte("test data for concurrent reading"))
-	gz.Close()
-	sourceData := source.Bytes()
-
-	var wg sync.WaitGroup
-	numGoroutines := 50
-
-	for i := 0; i < numGoroutines; i++ {
-		wg.Add(1)
-		go func(id int) {
-			defer wg.Done()
-			// Each goroutine needs its own reader for the data
-			buf := bytes.NewBuffer(sourceData)
-			gr, err := GetGzipReader(buf)
-			if err != nil {
-				// Handle error from failed reset
-				return
-			}
-			data, err := io.ReadAll(gr)
-			if err == nil {
-				assert.Equal(suite.T(), "test data for concurrent reading", string(data))
-			}
-			PutGzipReader(gr)
-		}(i)
-	}
-
-	wg.Wait()
-}
-
-func (suite *BufferPoolTestSuite) TestRaceConditions() {
-	var wg sync.WaitGroup
-	var bufferOps, gzipWriterOps, gzipReaderOps int32
-
-	// Buffer operations
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				buf := GetBuffer()
-				buf.WriteString("race test")
-				PutBuffer(buf)
-				atomic.AddInt32(&bufferOps, 1)
-			}
-		}()
-	}
-
-	// Gzip writer operations
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				var buf bytes.Buffer
-				gz := GetGzipWriter(&buf)
-				gz.Write([]byte("test"))
-				gz.Close()
-				PutGzipWriter(gz)
-				atomic.AddInt32(&gzipWriterOps, 1)
-			}
-		}()
-	}
-
-	// Gzip reader operations
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				var buf bytes.Buffer
-				gz := gzip.NewWriter(&buf)
-				gz.Write([]byte("test"))
-				gz.Close()
-
-				gr, err := GetGzipReader(&buf)
-				if err == nil {
-					io.ReadAll(gr)
-					PutGzipReader(gr)
-					atomic.AddInt32(&gzipReaderOps, 1)
-				}
-			}
-		}()
-	}
-
-	wg.Wait()
-
-	assert.Equal(suite.T(), int32(1000), atomic.LoadInt32(&bufferOps))
-	assert.Equal(suite.T(), int32(1000), atomic.LoadInt32(&gzipWriterOps))
-	assert.LessOrEqual(suite.T(), int32(900), atomic.LoadInt32(&gzipReaderOps)) // Some might fail
-}
-
-func (suite *BufferPoolTestSuite) TestGetStats() {
-	stats := GetStats()
-	assert.Equal(suite.T(), MaxBufferSize, stats.MaxBufferSize)
-	// BuffersInUse is always 0 in current implementation
-	assert.Equal(suite.T(), 0, stats.BuffersInUse)
-}
-
-func (suite *BufferPoolTestSuite) TestBufferGrowth() {
-	buf := GetBuffer()
-
-	// Write more than initial capacity
-	largeData := strings.Repeat("x", InitialBufferSize*2)
-	buf.WriteString(largeData)
-
-	assert.Equal(suite.T(), len(largeData), buf.Len())
-	assert.GreaterOrEqual(suite.T(), buf.Cap(), len(largeData))
-
-	PutBuffer(buf)
-}
-
-func (suite *BufferPoolTestSuite) TestMemoryEfficiency() {
-	// Test that pools actually reduce allocations
-	allocsBefore := testing.AllocsPerRun(100, func() {
-		buf := new(bytes.Buffer)
-		buf.WriteString("test")
-		_ = buf.String()
-	})
-
-	allocsWithPool := testing.AllocsPerRun(100, func() {
-		buf := GetBuffer()
-		buf.WriteString("test")
-		_ = buf.String()
-		PutBuffer(buf)
-	})
-
-	// Pool should reduce allocations
-	assert.Less(suite.T(), allocsWithPool, allocsBefore)
-}
-
-// Benchmark tests
-func BenchmarkBufferPool(b *testing.B) {
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			buf := GetBuffer()
-			buf.WriteString("benchmark test data")
-			PutBuffer(buf)
-		}
-	})
-}
-
-func BenchmarkGzipWriterPool(b *testing.B) {
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			var buf bytes.Buffer
-			gz := GetGzipWriter(&buf)
-			gz.Write([]byte("benchmark test data"))
-			gz.Close()
-			PutGzipWriter(gz)
-		}
-	})
-}
-
-func BenchmarkGzipReaderPool(b *testing.B) {
-	// Prepare compressed data
-	var compressed bytes.Buffer
-	gz := gzip.NewWriter(&compressed)
-	gz.Write([]byte("benchmark test data"))
-	gz.Close()
-	data := compressed.Bytes()
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			buf := bytes.NewBuffer(data)
-			gr, err := GetGzipReader(buf)
-			if err == nil {
-				io.ReadAll(gr)
-				PutGzipReader(gr)
-			}
-		}
-	})
-}
-
-func BenchmarkWithoutPool(b *testing.B) {
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			buf := new(bytes.Buffer)
-			buf.WriteString("benchmark test data")
-			// Buffer is discarded, letting GC handle it
-		}
-	})
-}

pools_security_test.go

@@ -1,562 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"math/rand"
-	"runtime"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-
-	"github.com/lukaszraczylo/graphql-monitoring-proxy/pkg/pools"
-	"github.com/stretchr/testify/suite"
-)
-
-type PoolsSecurityTestSuite struct {
-	suite.Suite
-}
-
-func TestPoolsSecurityTestSuite(t *testing.T) {
-	suite.Run(t, new(PoolsSecurityTestSuite))
-}
-
-// TestBufferPoolConcurrency tests concurrent Get/Put operations for thread safety
-func (suite *PoolsSecurityTestSuite) TestBufferPoolConcurrency() {
-	const numGoroutines = 100
-	const numOperationsPerGoroutine = 100
-
-	var wg sync.WaitGroup
-	errors := make(chan error, numGoroutines*numOperationsPerGoroutine)
-
-	suite.Run("Concurrent buffer pool operations", func() {
-		for i := 0; i < numGoroutines; i++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
-
-				for j := 0; j < numOperationsPerGoroutine; j++ {
-					// Get buffer from pool
-					buf := pools.GetBuffer()
-					if buf == nil {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: got nil buffer", goroutineID, j)
-						continue
-					}
-
-					// Verify buffer is reset/clean
-					if buf.Len() != 0 {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: buffer not reset, length: %d", goroutineID, j, buf.Len())
-						continue
-					}
-
-					// Use the buffer
-					testData := fmt.Sprintf("test data from goroutine %d iteration %d", goroutineID, j)
-					buf.WriteString(testData)
-
-					// Verify data was written correctly
-					if buf.String() != testData {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: data corruption", goroutineID, j)
-						continue
-					}
-
-					// Return buffer to pool
-					pools.PutBuffer(buf)
-
-					// Small random delay to increase chance of race conditions
-					if rand.Intn(10) == 0 {
-						time.Sleep(time.Microsecond)
-					}
-				}
-			}(i)
-		}
-
-		wg.Wait()
-		close(errors)
-
-		// Check for any errors
-		errorCount := 0
-		for err := range errors {
-			suite.T().Errorf("Concurrent operation failed: %v", err)
-			errorCount++
-		}
-
-		suite.Equal(0, errorCount, "Should have no errors in concurrent operations")
-	})
-}
-
-// TestBufferPoolMemoryLeak tests for memory leaks in buffer pooling
-func (suite *PoolsSecurityTestSuite) TestBufferPoolMemoryLeak() {
-	suite.Run("Memory leak prevention", func() {
-		var memBefore runtime.MemStats
-		runtime.GC()
-		runtime.ReadMemStats(&memBefore)
-
-		// Create many buffers and return them to pool
-		const numBuffers = 1000
-		buffers := make([]*bytes.Buffer, numBuffers)
-
-		for i := 0; i < numBuffers; i++ {
-			buffers[i] = pools.GetBuffer()
-			// Write some data
-			buffers[i].WriteString(strings.Repeat("a", 1024))
-		}
-
-		// Return all buffers to pool
-		for i := 0; i < numBuffers; i++ {
-			pools.PutBuffer(buffers[i])
-		}
-
-		// Clear references
-		for i := range buffers {
-			buffers[i] = nil
-		}
-		buffers = nil
-
-		// Force garbage collection
-		runtime.GC()
-		runtime.GC() // Second GC to ensure cleanup
-
-		var memAfter runtime.MemStats
-		runtime.ReadMemStats(&memAfter)
-
-		// Memory usage shouldn't increase dramatically
-		memDiff := int64(memAfter.Alloc) - int64(memBefore.Alloc)
-		maxAcceptableIncrease := int64(1024 * 1024) // 1MB
-
-		suite.LessOrEqual(memDiff, maxAcceptableIncrease,
-			"Memory usage increased by %d bytes, should be less than %d bytes",
-			memDiff, maxAcceptableIncrease)
-	})
-}
-
-// TestBufferSizeLimit tests that oversized buffers are not pooled
-func (suite *PoolsSecurityTestSuite) TestBufferSizeLimit() {
-	suite.Run("Oversized buffer rejection", func() {
-		buf := pools.GetBuffer()
-
-		// Write data larger than MaxBufferSize
-		largeData := make([]byte, pools.MaxBufferSize+1)
-		for i := range largeData {
-			largeData[i] = 'a'
-		}
-		buf.Write(largeData)
-
-		// Verify buffer is oversized
-		suite.Greater(buf.Cap(), pools.MaxBufferSize,
-			"Buffer capacity should exceed MaxBufferSize")
-
-		// Return oversized buffer to pool
-		pools.PutBuffer(buf)
-
-		// Get a new buffer - should be a fresh one, not the oversized one
-		newBuf := pools.GetBuffer()
-		suite.Equal(0, newBuf.Len(), "New buffer should be empty")
-		suite.LessOrEqual(newBuf.Cap(), pools.MaxBufferSize,
-			"New buffer capacity should be within limits")
-
-		pools.PutBuffer(newBuf)
-	})
-}
-
-// TestBufferPoolRaceConditions tests for race conditions in buffer pooling
-func (suite *PoolsSecurityTestSuite) TestBufferPoolRaceConditions() {
-	suite.Run("Race condition detection", func() {
-		const numGoroutines = 50
-		var wg sync.WaitGroup
-		bufferMap := sync.Map{} // Track buffers to detect sharing
-
-		for i := 0; i < numGoroutines; i++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
-
-				for j := 0; j < 50; j++ {
-					buf := pools.GetBuffer()
-					bufferAddr := fmt.Sprintf("%p", buf)
-
-					// Check if this buffer is already in use
-					if _, exists := bufferMap.LoadOrStore(bufferAddr, goroutineID); exists {
-						suite.T().Errorf("Buffer %s is being used by multiple goroutines", bufferAddr)
-						return
-					}
-
-					// Use buffer
-					buf.WriteString(fmt.Sprintf("goroutine-%d-op-%d", goroutineID, j))
-
-					// Simulate some work
-					time.Sleep(time.Microsecond * time.Duration(rand.Intn(10)))
-
-					// Remove from tracking and return to pool
-					bufferMap.Delete(bufferAddr)
-					pools.PutBuffer(buf)
-				}
-			}(i)
-		}
-
-		wg.Wait()
-	})
-}
-
-// TestGzipWriterPoolConcurrency tests concurrent operations on gzip writer pool
-func (suite *PoolsSecurityTestSuite) TestGzipWriterPoolConcurrency() {
-	const numGoroutines = 50
-	const numOperationsPerGoroutine = 20
-
-	var wg sync.WaitGroup
-	errors := make(chan error, numGoroutines*numOperationsPerGoroutine)
-
-	suite.Run("Concurrent gzip writer pool operations", func() {
-		for i := 0; i < numGoroutines; i++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
-
-				for j := 0; j < numOperationsPerGoroutine; j++ {
-					// Create a buffer for compressed data
-					buf := &bytes.Buffer{}
-
-					// Get gzip writer from pool
-					gz := pools.GetGzipWriter(buf)
-					if gz == nil {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: got nil gzip writer", goroutineID, j)
-						continue
-					}
-
-					// Write test data
-					testData := fmt.Sprintf("test data from goroutine %d iteration %d", goroutineID, j)
-					if _, err := gz.Write([]byte(testData)); err != nil {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: write error: %v", goroutineID, j, err)
-						continue
-					}
-
-					if err := gz.Close(); err != nil {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: close error: %v", goroutineID, j, err)
-						continue
-					}
-
-					// Verify compression worked
-					if buf.Len() == 0 {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: no compressed data", goroutineID, j)
-						continue
-					}
-
-					// Return writer to pool
-					pools.PutGzipWriter(gz)
-				}
-			}(i)
-		}
-
-		wg.Wait()
-		close(errors)
-
-		// Check for any errors
-		errorCount := 0
-		for err := range errors {
-			suite.T().Errorf("Concurrent gzip writer operation failed: %v", err)
-			errorCount++
-		}
-
-		suite.Equal(0, errorCount, "Should have no errors in concurrent gzip writer operations")
-	})
-}
-
-// TestGzipReaderPoolConcurrency tests concurrent operations on gzip reader pool
-func (suite *PoolsSecurityTestSuite) TestGzipReaderPoolConcurrency() {
-	// First, prepare some compressed data
-	testData := "Hello, World! This is test data for gzip reader pool testing."
-	var compressedBuf bytes.Buffer
-	gz := gzip.NewWriter(&compressedBuf)
-	gz.Write([]byte(testData))
-	gz.Close()
-	compressedData := compressedBuf.Bytes()
-
-	const numGoroutines = 30
-	const numOperationsPerGoroutine = 10
-
-	var wg sync.WaitGroup
-	errors := make(chan error, numGoroutines*numOperationsPerGoroutine)
-
-	suite.Run("Concurrent gzip reader pool operations", func() {
-		for i := 0; i < numGoroutines; i++ {
-			wg.Add(1)
-			go func(goroutineID int) {
-				defer wg.Done()
-
-				for j := 0; j < numOperationsPerGoroutine; j++ {
-					// Create reader from compressed data
-					reader := bytes.NewReader(compressedData)
-
-					// Get gzip reader from pool
-					gr, err := pools.GetGzipReader(reader)
-					if err != nil {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: error getting gzip reader: %v", goroutineID, j, err)
-						continue
-					}
-
-					// Read decompressed data
-					decompressed, err := io.ReadAll(gr)
-					if err != nil {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: read error: %v", goroutineID, j, err)
-						continue
-					}
-
-					// Verify data integrity
-					if string(decompressed) != testData {
-						errors <- fmt.Errorf("goroutine %d, iteration %d: data mismatch", goroutineID, j)
-						continue
-					}
-
-					// Return reader to pool
-					pools.PutGzipReader(gr)
-				}
-			}(i)
-		}
-
-		wg.Wait()
-		close(errors)
-
-		// Check for any errors
-		errorCount := 0
-		for err := range errors {
-			suite.T().Errorf("Concurrent gzip reader operation failed: %v", err)
-			errorCount++
-		}
-
-		suite.Equal(0, errorCount, "Should have no errors in concurrent gzip reader operations")
-	})
-}
-
-// TestPoolNilHandling tests proper handling of nil parameters
-func (suite *PoolsSecurityTestSuite) TestPoolNilHandling() {
-	suite.Run("Nil buffer handling", func() {
-		// Should not panic when putting nil buffer
-		suite.NotPanics(func() {
-			pools.PutBuffer(nil)
-		})
-	})
-
-	suite.Run("Nil gzip writer handling", func() {
-		// Should not panic when putting nil gzip writer
-		suite.NotPanics(func() {
-			pools.PutGzipWriter(nil)
-		})
-	})
-
-	suite.Run("Nil gzip reader handling", func() {
-		// Should not panic when putting nil gzip reader
-		suite.NotPanics(func() {
-			pools.PutGzipReader(nil)
-		})
-	})
-}
-
-// TestPoolResourceExhaustion tests behavior under resource exhaustion
-func (suite *PoolsSecurityTestSuite) TestPoolResourceExhaustion() {
-	suite.Run("Buffer pool under pressure", func() {
-		// Get many buffers without returning them
-		const numBuffers = 10000
-		buffers := make([]*bytes.Buffer, numBuffers)
-
-		for i := 0; i < numBuffers; i++ {
-			buffers[i] = pools.GetBuffer()
-			suite.NotNil(buffers[i], "Should always get a buffer (pool should create new ones)")
-		}
-
-		// Each buffer should be functional
-		for i := 0; i < numBuffers; i++ {
-			buffers[i].WriteString("test")
-			suite.Equal("test", buffers[i].String())
-		}
-
-		// Return all buffers
-		for i := 0; i < numBuffers; i++ {
-			pools.PutBuffer(buffers[i])
-		}
-	})
-}
-
-// TestPoolBufferReset tests that buffers are properly reset
-func (suite *PoolsSecurityTestSuite) TestPoolBufferReset() {
-	suite.Run("Buffer reset verification", func() {
-		// Get a buffer and write data
-		buf1 := pools.GetBuffer()
-		buf1.WriteString("sensitive data")
-		suite.Equal("sensitive data", buf1.String())
-
-		// Return to pool
-		pools.PutBuffer(buf1)
-
-		// Get another buffer (might be the same one)
-		buf2 := pools.GetBuffer()
-
-		// Should be empty (reset)
-		suite.Equal(0, buf2.Len(), "Buffer should be reset to empty")
-		suite.Equal("", buf2.String(), "Buffer content should be empty")
-
-		pools.PutBuffer(buf2)
-	})
-}
-
-// TestPoolGzipWriterReset tests that gzip writers are properly reset
-func (suite *PoolsSecurityTestSuite) TestPoolGzipWriterReset() {
-	suite.Run("Gzip writer reset verification", func() {
-		// First usage
-		buf1 := &bytes.Buffer{}
-		gz1 := pools.GetGzipWriter(buf1)
-		gz1.Write([]byte("data1"))
-		gz1.Close()
-
-		pools.PutGzipWriter(gz1)
-
-		// Second usage
-		buf2 := &bytes.Buffer{}
-		gz2 := pools.GetGzipWriter(buf2)
-		gz2.Write([]byte("data2"))
-		gz2.Close()
-
-		// Decompress to verify only "data2" is present
-		reader, err := gzip.NewReader(buf2)
-		suite.NoError(err)
-
-		decompressed, err := io.ReadAll(reader)
-		suite.NoError(err)
-		reader.Close()
-
-		suite.Equal("data2", string(decompressed),
-			"Gzip writer should be reset and not contain previous data")
-
-		pools.PutGzipWriter(gz2)
-	})
-}
-
-// TestPoolDataIsolation tests that data doesn't leak between pool uses
-func (suite *PoolsSecurityTestSuite) TestPoolDataIsolation() {
-	suite.Run("Buffer data isolation", func() {
-		// Create sensitive data pattern
-		sensitiveData := "password=secret123&api_key=sk-sensitive"
-
-		// Use buffer with sensitive data
-		buf1 := pools.GetBuffer()
-		buf1.WriteString(sensitiveData)
-		suite.Contains(buf1.String(), "secret123")
-
-		// Return to pool
-		pools.PutBuffer(buf1)
-
-		// Get new buffer and use it
-		buf2 := pools.GetBuffer()
-		buf2.WriteString("public data")
-
-		// Verify no sensitive data leaks
-		bufContent := buf2.String()
-		suite.NotContains(bufContent, "secret123", "Sensitive data should not leak")
-		suite.NotContains(bufContent, "sk-sensitive", "API key should not leak")
-		suite.Equal("public data", bufContent)
-
-		pools.PutBuffer(buf2)
-	})
-}
-
-// TestPoolIntegration tests integration between different pool types
-func (suite *PoolsSecurityTestSuite) TestPoolIntegration() {
-	suite.Run("Combined buffer and gzip operations", func() {
-		const numOperations = 100
-		var wg sync.WaitGroup
-		errors := make(chan error, numOperations)
-
-		for i := 0; i < numOperations; i++ {
-			wg.Add(1)
-			go func(opID int) {
-				defer wg.Done()
-
-				// Get buffer and gzip writer
-				buf := pools.GetBuffer()
-				gz := pools.GetGzipWriter(buf)
-
-				// Write test data
-				testData := fmt.Sprintf("operation %d test data", opID)
-				if _, err := gz.Write([]byte(testData)); err != nil {
-					errors <- fmt.Errorf("operation %d: write error: %v", opID, err)
-					return
-				}
-
-				if err := gz.Close(); err != nil {
-					errors <- fmt.Errorf("operation %d: close error: %v", opID, err)
-					return
-				}
-
-				// Verify compression worked
-				if buf.Len() == 0 {
-					errors <- fmt.Errorf("operation %d: no compressed data", opID)
-					return
-				}
-
-				// Test decompression with pool reader
-				gr, err := pools.GetGzipReader(bytes.NewReader(buf.Bytes()))
-				if err != nil {
-					errors <- fmt.Errorf("operation %d: reader error: %v", opID, err)
-					return
-				}
-
-				decompressed, err := io.ReadAll(gr)
-				if err != nil {
-					errors <- fmt.Errorf("operation %d: decompress error: %v", opID, err)
-					return
-				}
-
-				if string(decompressed) != testData {
-					errors <- fmt.Errorf("operation %d: data mismatch", opID)
-					return
-				}
-
-				// Return everything to pools
-				pools.PutGzipWriter(gz)
-				pools.PutBuffer(buf)
-				pools.PutGzipReader(gr)
-			}(i)
-		}
-
-		wg.Wait()
-		close(errors)
-
-		// Check for errors
-		errorCount := 0
-		for err := range errors {
-			suite.T().Errorf("Integration test failed: %v", err)
-			errorCount++
-		}
-
-		suite.Equal(0, errorCount, "Should have no errors in integration tests")
-	})
-}
-
-// BenchmarkBufferPoolOperations benchmarks buffer pool performance
-func BenchmarkBufferPoolOperations(b *testing.B) {
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			buf := pools.GetBuffer()
-			buf.WriteString("benchmark test data")
-			pools.PutBuffer(buf)
-		}
-	})
-}
-
-// BenchmarkGzipWriterPoolOperations benchmarks gzip writer pool performance
-func BenchmarkGzipWriterPoolOperations(b *testing.B) {
-	testData := []byte("benchmark test data for gzip compression")
-
-	b.ResetTimer()
-	b.RunParallel(func(pb *testing.PB) {
-		for pb.Next() {
-			buf := &bytes.Buffer{}
-			gz := pools.GetGzipWriter(buf)
-			gz.Write(testData)
-			gz.Close()
-			pools.PutGzipWriter(gz)
-		}
-	})
-}

proxy_logging_security_test.go

@@ -1,614 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/suite"
-)
-
-type ProxyLoggingSecurityTestSuite struct {
-	suite.Suite
-}
-
-func TestProxyLoggingSecurityTestSuite(t *testing.T) {
-	suite.Run(t, new(ProxyLoggingSecurityTestSuite))
-}
-
-// TestSensitiveDataSanitization tests that sensitive data is properly redacted from logs
-func (suite *ProxyLoggingSecurityTestSuite) TestSensitiveDataSanitization() {
-	tests := []struct {
-		name        string
-		input       map[string]interface{}
-		expected    map[string]interface{}
-		contentType string
-		description string
-	}{
-		{
-			name: "Password field redaction",
-			input: map[string]interface{}{
-				"username": "user123",
-				"password": "secret123",
-				"email":    "user@example.com",
-			},
-			expected: map[string]interface{}{
-				"username": "user123",
-				"password": "[REDACTED]",
-				"email":    "[REDACTED]",
-			},
-			contentType: "application/json",
-			description: "Should redact password and email fields",
-		},
-		{
-			name: "API key and token redaction",
-			input: map[string]interface{}{
-				"data":    "normal data",
-				"api_key": "sk-123456789",
-				"token":   "bearer-token-123",
-				"auth":    "auth-value",
-			},
-			expected: map[string]interface{}{
-				"data":    "normal data",
-				"api_key": "[REDACTED]",
-				"token":   "[REDACTED]",
-				"auth":    "[REDACTED]",
-			},
-			contentType: "application/json",
-			description: "Should redact API keys and tokens",
-		},
-		{
-			name: "Nested sensitive fields",
-			input: map[string]interface{}{
-				"user": map[string]interface{}{
-					"name":     "John Doe",
-					"password": "secret123",
-					"profile": map[string]interface{}{
-						"api_key": "sk-nested-key",
-						"bio":     "User bio",
-					},
-				},
-				"public_data": "visible",
-			},
-			expected: map[string]interface{}{
-				"user": map[string]interface{}{
-					"name":     "John Doe",
-					"password": "[REDACTED]",
-					"profile": map[string]interface{}{
-						"api_key": "[REDACTED]",
-						"bio":     "User bio",
-					},
-				},
-				"public_data": "visible",
-			},
-			contentType: "application/json",
-			description: "Should redact nested sensitive fields",
-		},
-		{
-			name: "Array with sensitive data",
-			input: map[string]interface{}{
-				"users": []interface{}{
-					map[string]interface{}{
-						"name":     "User1",
-						"password": "pass1",
-					},
-					map[string]interface{}{
-						"name":  "User2",
-						"token": "token2",
-					},
-				},
-			},
-			expected: map[string]interface{}{
-				"users": []interface{}{
-					map[string]interface{}{
-						"name":     "User1",
-						"password": "[REDACTED]",
-					},
-					map[string]interface{}{
-						"name":  "User2",
-						"token": "[REDACTED]",
-					},
-				},
-			},
-			contentType: "application/json",
-			description: "Should redact sensitive fields in arrays",
-		},
-		{
-			name: "Credit card and financial data",
-			input: map[string]interface{}{
-				"order_id":    "12345",
-				"credit_card": "4111111111111111",
-				"cvv":         "123",
-				"amount":      100.50,
-			},
-			expected: map[string]interface{}{
-				"order_id":    "12345",
-				"credit_card": "[REDACTED]",
-				"cvv":         "[REDACTED]",
-				"amount":      json.Number("100.5"),
-			},
-			contentType: "application/json",
-			description: "Should redact financial sensitive data",
-		},
-		{
-			name: "Personal identifiable information",
-			input: map[string]interface{}{
-				"name":    "John Doe",
-				"ssn":     "123-45-6789",
-				"phone":   "+1-555-123-4567",
-				"address": "123 Main St",
-				"age":     30,
-			},
-			expected: map[string]interface{}{
-				"name":    "John Doe",
-				"ssn":     "[REDACTED]",
-				"phone":   "[REDACTED]",
-				"address": "[REDACTED]",
-				"age":     json.Number("30"),
-			},
-			contentType: "application/json",
-			description: "Should redact PII data",
-		},
-		{
-			name: "Mixed case field names",
-			input: map[string]interface{}{
-				"UserName": "john",
-				"PASSWORD": "secret",
-				"Api_Key":  "key123",
-				"Bearer":   "token",
-			},
-			expected: map[string]interface{}{
-				"UserName": "john",
-				"PASSWORD": "[REDACTED]",
-				"Api_Key":  "[REDACTED]",
-				"Bearer":   "[REDACTED]",
-			},
-			contentType: "application/json",
-			description: "Should handle mixed case field names",
-		},
-		{
-			name: "Various password patterns",
-			input: map[string]interface{}{
-				"pwd":      "secret1",
-				"passwd":   "secret2",
-				"password": "secret3",
-				"pass":     "not-redacted", // Should NOT be redacted (not in list)
-			},
-			expected: map[string]interface{}{
-				"pwd":      "[REDACTED]",
-				"passwd":   "[REDACTED]",
-				"password": "[REDACTED]",
-				"pass":     "not-redacted",
-			},
-			contentType: "application/json",
-			description: "Should handle various password field patterns",
-		},
-		{
-			name: "Various auth patterns",
-			input: map[string]interface{}{
-				"authorization": "Bearer token123",
-				"auth":          "basic auth",
-				"bearer":        "token456",
-				"session":       "sess123",
-				"sessionid":     "session456",
-				"session_id":    "session789",
-				"cookie":        "cookie_value",
-			},
-			expected: map[string]interface{}{
-				"authorization": "[REDACTED]",
-				"auth":          "[REDACTED]",
-				"bearer":        "[REDACTED]",
-				"session":       "[REDACTED]",
-				"sessionid":     "[REDACTED]",
-				"session_id":    "[REDACTED]",
-				"cookie":        "[REDACTED]",
-			},
-			contentType: "application/json",
-			description: "Should handle various authentication field patterns",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			// Convert input to JSON bytes
-			inputBytes, err := json.Marshal(tt.input)
-			suite.NoError(err)
-
-			// Test the sanitization function
-			result := sanitizeForLogging(inputBytes, tt.contentType)
-
-			// Parse the result back to compare
-			var sanitized map[string]interface{}
-			decoder := json.NewDecoder(strings.NewReader(result))
-			decoder.UseNumber() // Preserve number precision and type
-			err = decoder.Decode(&sanitized)
-			suite.NoError(err, "Sanitized result should be valid JSON")
-
-			// Compare the result with expected
-			suite.Equal(tt.expected, sanitized, tt.description)
-
-			// Verify no sensitive data remains in the string representation
-			resultStr := strings.ToLower(result)
-			if strings.Contains(tt.name, "password") || strings.Contains(tt.name, "secret") {
-				suite.NotContains(resultStr, "secret", "Should not contain 'secret' in result")
-			}
-			if strings.Contains(tt.name, "key") {
-				suite.NotContains(resultStr, "sk-", "Should not contain API key prefix")
-			}
-		})
-	}
-}
-
-// TestSensitiveDataSanitizationNonJSON tests sanitization for non-JSON content
-func (suite *ProxyLoggingSecurityTestSuite) TestSensitiveDataSanitizationNonJSON() {
-	tests := []struct {
-		name                   string
-		input                  string
-		contentType            string
-		description            string
-		shouldNotContain       []string
-		shouldContainSanitized []string
-	}{
-		{
-			name:                   "Form data with password",
-			input:                  "username=john&password=secret123&email=john@example.com",
-			contentType:            "application/x-www-form-urlencoded",
-			shouldNotContain:       []string{"secret123"},
-			shouldContainSanitized: []string{"password=[REDACTED]"},
-			description:            "Should redact password in form data",
-		},
-		{
-			name:                   "Query string with sensitive data",
-			input:                  "?user=john&api_key=sk-123456&public=data",
-			contentType:            "text/plain",
-			shouldNotContain:       []string{"sk-123456"},
-			shouldContainSanitized: []string{"api_key=[REDACTED]"},
-			description:            "Should redact API key in query string",
-		},
-		{
-			name:                   "Large body truncation",
-			input:                  strings.Repeat("a", 1500) + "password=secret",
-			contentType:            "text/plain",
-			shouldNotContain:       []string{},
-			shouldContainSanitized: []string{"[truncated]"},
-			description:            "Should truncate large bodies",
-		},
-		{
-			name:                   "XML-like content with sensitive data",
-			input:                  "<user><name>John</name><password>secret123</password></user>",
-			contentType:            "application/xml",
-			shouldNotContain:       []string{"secret123"},
-			shouldContainSanitized: []string{"password=[REDACTED]"},
-			description:            "Should redact sensitive data in XML-like content",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result := sanitizeForLogging([]byte(tt.input), tt.contentType)
-
-			// Check that sensitive data is removed
-			for _, sensitiveData := range tt.shouldNotContain {
-				suite.NotContains(result, sensitiveData,
-					"Result should not contain sensitive data: %s", sensitiveData)
-			}
-
-			// Check that redaction markers are present
-			for _, redactedPattern := range tt.shouldContainSanitized {
-				suite.Contains(result, redactedPattern,
-					"Result should contain redaction marker: %s", redactedPattern)
-			}
-		})
-	}
-}
-
-// TestSanitizeHeaders tests header sanitization
-func (suite *ProxyLoggingSecurityTestSuite) TestSanitizeHeaders() {
-	tests := []struct {
-		input    map[string]string
-		expected map[string]string
-		name     string
-	}{
-		{
-			name: "Authorization header redaction",
-			input: map[string]string{
-				"Content-Type":  "application/json",
-				"Authorization": "Bearer token123",
-				"User-Agent":    "Test/1.0",
-			},
-			expected: map[string]string{
-				"Content-Type":  "application/json",
-				"Authorization": "[REDACTED]",
-				"User-Agent":    "Test/1.0",
-			},
-		},
-		{
-			name: "API key headers redaction",
-			input: map[string]string{
-				"X-API-Key":      "sk-123456",
-				"X-Auth-Token":   "auth-token-123",
-				"X-API-Secret":   "secret-key",
-				"Content-Length": "100",
-			},
-			expected: map[string]string{
-				"X-API-Key":      "[REDACTED]",
-				"X-Auth-Token":   "[REDACTED]",
-				"X-API-Secret":   "[REDACTED]",
-				"Content-Length": "100",
-			},
-		},
-		{
-			name: "Cookie headers redaction",
-			input: map[string]string{
-				"Cookie":     "sessionid=abc123; userid=456",
-				"Set-Cookie": "token=xyz789; Path=/",
-				"Host":       "example.com",
-			},
-			expected: map[string]string{
-				"Cookie":     "[REDACTED]",
-				"Set-Cookie": "[REDACTED]",
-				"Host":       "example.com",
-			},
-		},
-		{
-			name: "Mixed case headers",
-			input: map[string]string{
-				"AUTHORIZATION": "Bearer token",
-				"x-api-key":     "key123",
-				"Content-TYPE":  "json",
-			},
-			expected: map[string]string{
-				"AUTHORIZATION": "[REDACTED]",
-				"x-api-key":     "[REDACTED]",
-				"Content-TYPE":  "json",
-			},
-		},
-		{
-			name: "CSRF and access tokens",
-			input: map[string]string{
-				"X-CSRF-Token":   "csrf123",
-				"X-Access-Token": "access456",
-				"Accept":         "application/json",
-			},
-			expected: map[string]string{
-				"X-CSRF-Token":   "[REDACTED]",
-				"X-Access-Token": "[REDACTED]",
-				"Accept":         "application/json",
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result := sanitizeHeaders(tt.input)
-			suite.Equal(tt.expected, result)
-
-			// Verify original headers are not modified
-			for key, originalValue := range tt.input {
-				suite.Equal(originalValue, tt.input[key],
-					"Original headers should not be modified")
-			}
-		})
-	}
-}
-
-// TestRedactSensitiveFields tests the recursive redaction function
-func (suite *ProxyLoggingSecurityTestSuite) TestRedactSensitiveFields() {
-	sensitiveFields := []string{"password", "token", "secret"}
-
-	suite.Run("Deep nested structure", func() {
-		data := map[string]interface{}{
-			"level1": map[string]interface{}{
-				"level2": map[string]interface{}{
-					"level3": map[string]interface{}{
-						"password": "testdeepsecret",
-						"public":   "data",
-					},
-					"token": "testlevel2token",
-				},
-				"normal": "value",
-			},
-			"secret": "testtoplevel",
-		}
-
-		redactSensitiveFields(data, sensitiveFields)
-
-		// Verify deep nesting is handled
-		level3 := data["level1"].(map[string]interface{})["level2"].(map[string]interface{})["level3"].(map[string]interface{})
-		suite.Equal("[REDACTED]", level3["password"])
-		suite.Equal("data", level3["public"])
-
-		// Verify intermediate levels
-		level2 := data["level1"].(map[string]interface{})["level2"].(map[string]interface{})
-		suite.Equal("[REDACTED]", level2["token"])
-
-		// Verify top level
-		suite.Equal("[REDACTED]", data["secret"])
-		level1 := data["level1"].(map[string]interface{})
-		suite.Equal("value", level1["normal"])
-	})
-
-	suite.Run("Array of objects", func() {
-		data := map[string]interface{}{
-			"users": []interface{}{
-				map[string]interface{}{
-					"name":     "User1",
-					"password": "testpass1",
-				},
-				map[string]interface{}{
-					"name":  "User2",
-					"token": "testtoken2",
-				},
-				"not-an-object", // Should be ignored
-			},
-		}
-
-		redactSensitiveFields(data, sensitiveFields)
-
-		users := data["users"].([]interface{})
-		user1 := users[0].(map[string]interface{})
-		user2 := users[1].(map[string]interface{})
-
-		suite.Equal("[REDACTED]", user1["password"])
-		suite.Equal("User1", user1["name"])
-		suite.Equal("[REDACTED]", user2["token"])
-		suite.Equal("User2", user2["name"])
-		suite.Equal("not-an-object", users[2])
-	})
-}
-
-// TestRedactPatternInString tests string pattern redaction
-func (suite *ProxyLoggingSecurityTestSuite) TestRedactPatternInString() {
-	tests := []struct {
-		name     string
-		input    string
-		pattern  string
-		expected string
-	}{
-		{
-			name:     "JSON-style pattern",
-			input:    `{"password": "secret123", "user": "john"}`,
-			pattern:  "password",
-			expected: `{"password":"[REDACTED]", "user": "john"}`,
-		},
-		{
-			name:     "Form-style pattern with equals",
-			input:    "username=john&password=secret&email=test",
-			pattern:  "password",
-			expected: "username=john&password=[REDACTED]&email=test",
-		},
-		{
-			name:     "Double quoted pattern",
-			input:    `password="secret123"`,
-			pattern:  "password",
-			expected: `password="[REDACTED]"`,
-		},
-		{
-			name:     "Single quoted pattern",
-			input:    `password='secret123'`,
-			pattern:  "password",
-			expected: `password='[REDACTED]'`,
-		},
-		{
-			name:     "No match",
-			input:    "normal text without sensitive data",
-			pattern:  "password",
-			expected: "normal text without sensitive data",
-		},
-	}
-
-	for _, tt := range tests {
-		suite.Run(tt.name, func() {
-			result := redactPatternInString(tt.input, tt.pattern)
-			suite.Equal(tt.expected, result)
-		})
-	}
-}
-
-// TestSanitizationPerformance tests performance of sanitization functions
-func (suite *ProxyLoggingSecurityTestSuite) TestSanitizationPerformance() {
-	// Create a large JSON structure with sensitive data
-	largeData := make(map[string]interface{})
-	for i := 0; i < 1000; i++ {
-		largeData[fmt.Sprintf("user_%d", i)] = map[string]interface{}{
-			"name":     fmt.Sprintf("User%d", i),
-			"password": fmt.Sprintf("secret%d", i),
-			"email":    fmt.Sprintf("user%d@example.com", i),
-			"public":   fmt.Sprintf("public_data_%d", i),
-		}
-	}
-
-	largeJSON, err := json.Marshal(largeData)
-	suite.NoError(err)
-
-	// Test that sanitization completes in reasonable time
-	result := sanitizeForLogging(largeJSON, "application/json")
-
-	// Verify the result is valid JSON
-	var sanitized map[string]interface{}
-	err = json.Unmarshal([]byte(result), &sanitized)
-	suite.NoError(err)
-
-	// Verify sensitive data was redacted (spot check)
-	user0 := sanitized["user_0"].(map[string]interface{})
-	suite.Equal("[REDACTED]", user0["password"])
-	suite.Equal("[REDACTED]", user0["email"])
-	suite.Equal("User0", user0["name"])
-}
-
-// TestEdgeCases tests edge cases and error conditions
-func (suite *ProxyLoggingSecurityTestSuite) TestEdgeCases() {
-	suite.Run("Empty body", func() {
-		result := sanitizeForLogging([]byte{}, "application/json")
-		suite.Equal("", result)
-	})
-
-	suite.Run("Invalid JSON", func() {
-		invalidJSON := []byte(`{"invalid": json}`)
-		result := sanitizeForLogging(invalidJSON, "application/json")
-		// Should fall back to string sanitization
-		suite.Contains(result, "invalid")
-	})
-
-	suite.Run("Nil data", func() {
-		// Test with nil maps (should not panic)
-		sensitiveFields := []string{"password"}
-
-		// This should not panic
-		suite.NotPanics(func() {
-			data := make(map[string]interface{})
-			data["test"] = nil
-			redactSensitiveFields(data, sensitiveFields)
-		})
-	})
-
-	suite.Run("Empty headers", func() {
-		result := sanitizeHeaders(map[string]string{})
-		suite.Equal(map[string]string{}, result)
-	})
-
-	suite.Run("Very large content type", func() {
-		largeContentType := strings.Repeat("json", 1000)
-		result := sanitizeForLogging([]byte(`{"test": "data"}`), largeContentType)
-		suite.Contains(result, "test")
-	})
-}
-
-// BenchmarkSanitizeForLogging benchmarks the sanitization function
-func BenchmarkSanitizeForLogging(b *testing.B) {
-	testData := map[string]interface{}{
-		"username": "testuser",
-		"password": "secret123",
-		"api_key":  "sk-123456789",
-		"data":     "normal data",
-		"nested": map[string]interface{}{
-			"token": "nested-token",
-			"value": "nested-value",
-		},
-	}
-
-	jsonData, _ := json.Marshal(testData)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		sanitizeForLogging(jsonData, "application/json")
-	}
-}
-
-// BenchmarkSanitizeHeaders benchmarks header sanitization
-func BenchmarkSanitizeHeaders(b *testing.B) {
-	headers := map[string]string{
-		"Content-Type":   "application/json",
-		"Authorization":  "Bearer token123",
-		"X-API-Key":      "sk-123456",
-		"User-Agent":     "Test/1.0",
-		"Accept":         "application/json",
-		"Content-Length": "100",
-	}
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		sanitizeHeaders(headers)
-	}
-}

proxy_test.go

@@ -9,6 +9,7 @@ import (
 )
 
 func (suite *Tests) Test_proxyTheRequest() {
+
 	supplied_headers := map[string]string{
 		"X-Forwarded-For": "127.0.0.1",
 		"Content-Type":    "application/json",
@@ -21,8 +22,8 @@ func (suite *Tests) Test_proxyTheRequest() {
 		host         string
 		hostRO       string
 		path         string
-		wantEndpoint string
 		wantErr      bool
+		wantEndpoint string
 	}{
 		{
 			name:         "test_empty",
@@ -73,49 +74,11 @@ func (suite *Tests) Test_proxyTheRequest() {
 			wantErr:      false,
 			wantEndpoint: "https://telegram-bot.app/",
 		},
-		{
-			name:         "Test query string preservation",
-			body:         `{"query":"query {\n            __type(name: \"Query\") {\n              name\n            }\n          }"}`,
-			host:         "https://telegram-bot.app/",
-			path:         "/v1/graphql?var=value&foo=bar",
-			headers:      supplied_headers,
-			wantErr:      false,
-			wantEndpoint: "https://telegram-bot.app/",
-		},
-		{
-			name:         "Test mutation with multiple operations (bug fix regression test)",
-			body:         `{"query":"mutation getOrCreateUser { insert_tg_users_one(object: {id: 123}) { id } } query otherQuery { users { id } }"}`,
-			host:         "https://telegram-bot.app/",
-			hostRO:       "https://google.com/",
-			path:         "/v1/graphql",
-			headers:      supplied_headers,
-			wantErr:      false,
-			wantEndpoint: "https://telegram-bot.app/",
-		},
-		{
-			name:         "Test mutation followed by fragment (bug fix regression test)",
-			body:         `{"query":"mutation insertUser { insert_users_one(object: {name: \"test\"}) { ...userFields } } fragment userFields on users { id name }"}`,
-			host:         "https://telegram-bot.app/",
-			hostRO:       "https://google.com/",
-			path:         "/v1/graphql",
-			headers:      supplied_headers,
-			wantErr:      false,
-			wantEndpoint: "https://telegram-bot.app/",
-		},
-		{
-			name:         "Test complex mutation document (main-bot style)",
-			body:         `{"query":"mutation getOrCreateUser($user_id: bigint!, $group_id: bigint!) { insert_tg_users_one(object: {id: $user_id}, on_conflict: {constraint: tg_users_pkey, update_columns: last_seen}) { id } insert_tg_groups_one(object: {id: $group_id}, on_conflict: {constraint: tg_groups_pkey, update_columns: last_seen}) { id } }"}`,
-			host:         "https://telegram-bot.app/",
-			hostRO:       "https://google.com/",
-			path:         "/v1/graphql",
-			headers:      supplied_headers,
-			wantErr:      false,
-			wantEndpoint: "https://telegram-bot.app/",
-		},
 	}
 
 	for _, tt := range tests {
 		suite.Run(tt.name, func() {
+
 			cfg = &config{}
 			parseConfig()
 			cfg.Server.HostGraphQL = tt.host
@@ -124,35 +87,32 @@ func (suite *Tests) Test_proxyTheRequest() {
 				cfg.Server.HostGraphQLReadOnly = tt.hostRO
 			}
 
-			// Create a request context first
-			reqCtx := &fasthttp.RequestCtx{}
-
-			// Set headers directly on the request
+			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
+			
+			// Set headers
 			for k, v := range tt.headers {
-				reqCtx.Request.Header.Add(k, v)
+				ctx.Request().Header.Add(k, v)
 			}
 
-			// Set the body and other request properties
-			reqCtx.Request.SetBody([]byte(tt.body))
-			reqCtx.Request.SetRequestURI(tt.path)
-			reqCtx.Request.Header.SetMethod("POST")
-
-			// Create fiber context with the request context
-			ctx := suite.app.AcquireCtx(reqCtx)
+			// Set body and other request properties
+			ctx.Request().SetBody([]byte(tt.body))
+			ctx.Request().SetRequestURI(tt.path)
+			ctx.Request().Header.SetMethod("POST")
 			res := parseGraphQLQuery(ctx)
-			suite.NotNil(ctx, "Fiber context is nil", tt.name)
+			assert.NotNil(ctx, "Fiber context is nil", tt.name)
 			err := proxyTheRequest(ctx, res.activeEndpoint)
 			if tt.wantErr {
-				suite.NotNil(err, "Error is nil", tt.name)
+				assert.NotNil(err, "Error is nil", tt.name)
 			} else {
-				suite.Nil(err, "Error is not nil", tt.name)
+				assert.Nil(err, "Error is not nil", tt.name)
 			}
-			suite.Equal(tt.wantEndpoint, res.activeEndpoint, "Unexpected endpoint", tt.name)
+			assert.Equal(tt.wantEndpoint, res.activeEndpoint, "Unexpected endpoint", tt.name)
 		})
 	}
 }
 
 func (suite *Tests) Test_proxyTheRequestWithPayloads() {
+
 	tests := []struct {
 		name    string
 		payload string
@@ -185,9 +145,9 @@ func (suite *Tests) Test_proxyTheRequestWithPayloads() {
 			ctx := suite.app.AcquireCtx(&fasthttp.RequestCtx{})
 			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
 			if tt.wantErr {
-				suite.NotNil(err)
+				assert.NotNil(err)
 			} else {
-				suite.Nil(err)
+				assert.Nil(err)
 			}
 		})
 	}
@@ -197,7 +157,7 @@ func (suite *Tests) Test_proxyTheRequestWithTimeouts() {
 	originalTimeout := cfg.Client.ClientTimeout
 	defer func() {
 		cfg.Client.ClientTimeout = originalTimeout
-		cfg.Client.FastProxyClient = createFasthttpClient(cfg)
+		cfg.Client.FastProxyClient = createFasthttpClient(cfg.Client.ClientTimeout)
 	}()
 
 	// Create a mock server
@@ -205,15 +165,15 @@ func (suite *Tests) Test_proxyTheRequestWithTimeouts() {
 		sleepDuration, _ := time.ParseDuration(r.Header.Get("X-Sleep-Duration"))
 		time.Sleep(sleepDuration)
 		w.WriteHeader(http.StatusOK)
-		_, _ = w.Write([]byte(`{"data":{"test":"response"}}`))
+		w.Write([]byte(`{"data":{"test":"response"}}`))
 	}))
 	defer mockServer.Close()
 
 	tests := []struct {
 		name          string
+		clientTimeout int
 		sleepDuration string
 		body          string
-		clientTimeout int
 		wantErr       bool
 	}{
 		{
@@ -242,7 +202,7 @@ func (suite *Tests) Test_proxyTheRequestWithTimeouts() {
 	for _, tt := range tests {
 		suite.Run(tt.name, func() {
 			cfg.Client.ClientTimeout = tt.clientTimeout
-			cfg.Client.FastProxyClient = createFasthttpClient(cfg)
+			cfg.Client.FastProxyClient = createFasthttpClient(cfg.Client.ClientTimeout)
 			cfg.Server.HostGraphQL = mockServer.URL
 
 			req := &fasthttp.Request{}
@@ -262,9 +222,9 @@ func (suite *Tests) Test_proxyTheRequestWithTimeouts() {
 			err := proxyTheRequest(ctx, cfg.Server.HostGraphQL)
 
 			if tt.wantErr {
-				suite.NotNil(err, "Expected an error for test: %s", tt.name)
+				assert.NotNil(err, "Expected an error for test: %s", tt.name)
 			} else {
-				suite.Nil(err, "Expected no error for test: %s", tt.name)
+				assert.Nil(err, "Expected no error for test: %s", tt.name)
 			}
 		})
 	}

ratelimit.go

@@ -1,10 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"os"
 	"sync"
-	"sync/atomic"
 	"time"
 
 	"github.com/goccy/go-json"
@@ -15,118 +13,38 @@ import (
 // RateLimitConfig holds the rate limit configuration for a role
 type RateLimitConfig struct {
 	RateCounterTicker *goratecounter.RateCounter
-	Endpoints         []string      `json:"endpoints,omitempty"`
 	Interval          time.Duration `json:"interval"`
 	Req               int           `json:"req"`
-	Burst             int           `json:"burst,omitempty"`
-}
-
-// UnmarshalJSON implements custom JSON unmarshaling for RateLimitConfig
-func (r *RateLimitConfig) UnmarshalJSON(data []byte) error {
-	// Use a temporary struct to unmarshal the JSON data
-	type RateLimitConfigTemp struct {
-		Interval interface{} `json:"interval"`
-		Req      int         `json:"req"`
-	}
-
-	var temp RateLimitConfigTemp
-	if err := json.Unmarshal(data, &temp); err != nil {
-		return err
-	}
-
-	// Set the Req field directly
-	r.Req = temp.Req
-
-	// Handle the Interval field based on its type
-	switch v := temp.Interval.(type) {
-	case string:
-		// Convert string to time.Duration
-		switch v {
-		case "second":
-			r.Interval = time.Second
-		case "minute":
-			r.Interval = time.Minute
-		case "hour":
-			r.Interval = time.Hour
-		case "day":
-			r.Interval = 24 * time.Hour
-		default:
-			// Try to parse as a Go duration string (e.g. "1s", "5m")
-			var err error
-			r.Interval, err = time.ParseDuration(v)
-			if err != nil {
-				return fmt.Errorf("invalid duration format: %s", v)
-			}
-		}
-	case float64:
-		// Numeric value is assumed to be in seconds
-		r.Interval = time.Duration(v * float64(time.Second))
-	default:
-		return fmt.Errorf("interval must be a string or number, got %T", v)
-	}
-
-	return nil
 }
 
 var (
 	rateLimits  = make(map[string]RateLimitConfig)
 	rateLimitMu sync.RWMutex
-	// Use atomic.Value for safe concurrent config swapping
-	rateLimitConfigAtomic atomic.Value
 )
 
-// Variable to hold the current load config function - allows for testing
-var loadConfigFunc = loadConfigFromPath
-
 // loadRatelimitConfig loads the rate limit configurations from file
 func loadRatelimitConfig() error {
 	paths := []string{"/go/src/app/ratelimit.json", "./ratelimit.json", "./static/app/default-ratelimit.json"}
-	configError := NewRateLimitConfigError(paths)
-
-	// Try each path and collect detailed error information
 	for _, path := range paths {
-		if err := loadConfigFunc(path); err == nil {
+		if err := loadConfigFromPath(path); err == nil {
 			return nil
-		} else {
-			// Store the specific error for this path
-			configError.PathErrors[path] = err.Error()
 		}
 	}
-
-	// Log detailed error information
 	cfg.Logger.Error(&libpack_logger.LogMessage{
-		Message: "Failed to load rate limit configuration",
-		Pairs: map[string]interface{}{
-			"paths":       paths,
-			"path_errors": configError.PathErrors,
-		},
+		Message: "Rate limit config not found",
+		Pairs:   map[string]interface{}{"paths": paths},
 	})
-
-	return configError
+	return os.ErrNotExist
 }
 
 func loadConfigFromPath(path string) error {
 	file, err := os.ReadFile(path)
 	if err != nil {
-		// Provide more specific error message based on the error type
-		errMsg := ""
-		if os.IsNotExist(err) {
-			errMsg = "File not found"
-		} else if os.IsPermission(err) {
-			errMsg = "Permission denied"
-		} else {
-			errMsg = "I/O error: " + err.Error()
-		}
-
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Failed to load rate limit config",
-			Pairs: map[string]interface{}{
-				"path":          path,
-				"error":         errMsg,
-				"error_details": err.Error(),
-			},
+			Message: "Failed to load config",
+			Pairs:   map[string]interface{}{"path": path, "error": err},
 		})
-		return fmt.Errorf("%s", errMsg)
+		return err
 	}
 
 	var config struct {
@@ -134,28 +52,7 @@ func loadConfigFromPath(path string) error {
 	}
 
 	if err := json.Unmarshal(file, &config); err != nil {
-		errMsg := fmt.Sprintf("Invalid JSON format: %s", err.Error())
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Failed to parse rate limit config",
-			Pairs: map[string]interface{}{
-				"path":  path,
-				"error": errMsg,
-			},
-		})
-		return fmt.Errorf("%s", errMsg)
-	}
-
-	// Validate configuration
-	if len(config.RateLimit) == 0 {
-		errMsg := "Empty rate limit configuration"
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Invalid rate limit config",
-			Pairs: map[string]interface{}{
-				"path":  path,
-				"error": errMsg,
-			},
-		})
-		return fmt.Errorf("%s", errMsg)
+		return err
 	}
 
 	newRateLimits := make(map[string]RateLimitConfig, len(config.RateLimit))
@@ -177,11 +74,8 @@ func loadConfigFromPath(path string) error {
 		newRateLimits[key] = value
 	}
 
-	// Use atomic swap for thread-safe configuration updates
 	rateLimitMu.Lock()
 	rateLimits = newRateLimits
-	// Store the new config atomically
-	rateLimitConfigAtomic.Store(newRateLimits)
 	rateLimitMu.Unlock()
 
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
@@ -193,34 +87,18 @@ func loadConfigFromPath(path string) error {
 
 // rateLimitedRequest checks if a request should be rate-limited
 func rateLimitedRequest(userID, userRole string) bool {
-	// Try to get config from atomic value first for better performance
-	if configInterface := rateLimitConfigAtomic.Load(); configInterface != nil {
-		if config, ok := configInterface.(map[string]RateLimitConfig); ok {
-			if roleConfig, exists := config[userRole]; exists && roleConfig.RateCounterTicker != nil {
-				return checkRateLimit(userID, userRole, roleConfig, "")
-			}
-		}
-	}
-
-	// Fallback to mutex-protected access
 	rateLimitMu.RLock()
 	roleConfig, ok := rateLimits[userRole]
 	rateLimitMu.RUnlock()
 
 	if !ok || roleConfig.RateCounterTicker == nil {
-		cfg.Logger.Warning(&libpack_logger.LogMessage{
-			Message: "Rate limit role not found or ticker not initialized - defaulting to deny",
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Rate limit role not found or ticker not initialized",
 			Pairs:   map[string]interface{}{"user_role": userRole},
 		})
-		// Default to deny when config not found (security fix)
-		return false
+		return true
 	}
 
-	return checkRateLimit(userID, userRole, roleConfig, "")
-}
-
-// checkRateLimit performs the actual rate limit check
-func checkRateLimit(userID, userRole string, roleConfig RateLimitConfig, endpoint string) bool {
 	roleConfig.RateCounterTicker.Incr(1)
 	tickerRate := roleConfig.RateCounterTicker.GetRate()
 
@@ -230,7 +108,6 @@ func checkRateLimit(userID, userRole string, roleConfig RateLimitConfig, endpoin
 		"rate":        tickerRate,
 		"config_rate": roleConfig.Req,
 		"interval":    roleConfig.Interval,
-		"endpoint":    endpoint,
 	}
 
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
@@ -238,15 +115,6 @@ func checkRateLimit(userID, userRole string, roleConfig RateLimitConfig, endpoin
 		Pairs:   map[string]interface{}{"log_details": logDetails},
 	})
 
-	// Check burst limit if configured
-	if roleConfig.Burst > 0 && tickerRate > float64(roleConfig.Burst) {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Burst limit exceeded",
-			Pairs:   map[string]interface{}{"log_details": logDetails},
-		})
-		return false
-	}
-
 	if tickerRate > float64(roleConfig.Req) {
 		cfg.Logger.Debug(&libpack_logger.LogMessage{
 			Message: "Rate limit exceeded",

ratelimit_errors.go

@@ -1,58 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"strings"
-)
-
-// RateLimitConfigError represents a detailed error when loading rate limit configuration
-type RateLimitConfigError struct {
-	PathErrors map[string]string
-	Paths      []string
-}
-
-// Error implements the error interface
-func (e *RateLimitConfigError) Error() string {
-	sb := strings.Builder{}
-	sb.WriteString("Failed to load rate limit configuration. Please ensure a valid configuration file exists at one of these locations:\n")
-
-	for _, path := range e.Paths {
-		errMsg := e.PathErrors[path]
-		sb.WriteString(fmt.Sprintf("  - %s: %s\n", path, errMsg))
-	}
-
-	sb.WriteString("\nTo resolve this issue:\n")
-	sb.WriteString("1. Create a valid JSON file using the following template:\n")
-	sb.WriteString(`   {
-	    "ratelimit": {
-	      "admin": {
-	        "req": 100,
-	        "interval": "second"
-	      },
-	      "guest": {
-	        "req": 3,
-	        "interval": "second"
-	      },
-	      "-": {
-	        "req": 10,
-	        "interval": "minute"
-	      }
-	    }
-	  }`)
-	sb.WriteString("\n\nThe 'interval' field supports the following formats:\n")
-	sb.WriteString("  - String values: \"second\", \"minute\", \"hour\", \"day\"\n")
-	sb.WriteString("  - Go duration strings: \"5s\", \"10m\", \"1h\"\n")
-	sb.WriteString("  - Numeric values (in seconds): 60, 3600\n")
-	sb.WriteString("\n2. Save it as 'ratelimit.json' in the current directory or in '/go/src/app/' (in Docker)\n")
-	sb.WriteString("3. Ensure the file has correct permissions and is accessible by the service\n")
-
-	return sb.String()
-}
-
-// NewRateLimitConfigError creates a new rate limit configuration error
-func NewRateLimitConfigError(paths []string) *RateLimitConfigError {
-	return &RateLimitConfigError{
-		Paths:      paths,
-		PathErrors: make(map[string]string),
-	}
-}

ratelimit_test.go

@@ -1,277 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/goccy/go-json"
-	goratecounter "github.com/lukaszraczylo/go-ratecounter"
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-func (suite *Tests) Test_loadRatelimitConfig() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Create a temporary test ratelimit.json file
-	tempDir := os.TempDir()
-	testConfigPath := filepath.Join(tempDir, "test_ratelimit.json")
-
-	testConfig := struct {
-		RateLimit map[string]RateLimitConfig `json:"ratelimit"`
-	}{
-		RateLimit: map[string]RateLimitConfig{
-			"admin": {
-				Interval: 1 * time.Second,
-				Req:      100,
-			},
-			"user": {
-				Interval: 1 * time.Second,
-				Req:      10,
-			},
-		},
-	}
-
-	configData, err := json.Marshal(testConfig)
-	suite.NoError(err)
-
-	err = os.WriteFile(testConfigPath, configData, 0o644)
-	suite.NoError(err)
-	defer func() { _ = os.Remove(testConfigPath) }()
-
-	// Test loading config from custom path
-	suite.Run("load from custom path", func() {
-		// Clear existing rate limits
-		rateLimitMu.Lock()
-		rateLimits = make(map[string]RateLimitConfig)
-		rateLimitMu.Unlock()
-
-		err := loadConfigFromPath(testConfigPath)
-		suite.NoError(err)
-
-		// Verify rate limits were loaded
-		rateLimitMu.RLock()
-		defer rateLimitMu.RUnlock()
-
-		suite.Equal(2, len(rateLimits))
-		suite.Contains(rateLimits, "admin")
-		suite.Contains(rateLimits, "user")
-		suite.Equal(100, rateLimits["admin"].Req)
-		suite.Equal(10, rateLimits["user"].Req)
-		suite.NotNil(rateLimits["admin"].RateCounterTicker)
-		suite.NotNil(rateLimits["user"].RateCounterTicker)
-	})
-
-	// Test loading config from non-existent path
-	suite.Run("load from non-existent path", func() {
-		err := loadConfigFromPath("/non/existent/path.json")
-		suite.Error(err)
-	})
-
-	// Test loading config with invalid JSON
-	suite.Run("load invalid JSON", func() {
-		invalidPath := filepath.Join(tempDir, "invalid_ratelimit.json")
-		err := os.WriteFile(invalidPath, []byte("{invalid json}"), 0o644)
-		suite.NoError(err)
-		defer func() { _ = os.Remove(invalidPath) }()
-
-		err = loadConfigFromPath(invalidPath)
-		suite.Error(err)
-	})
-
-	// Test with a temporary ratelimit.json file in the current directory
-	suite.Run("load from current directory", func() {
-		// Create a temporary ratelimit.json in current directory
-		currentDirPath := "./ratelimit.json"
-		err := os.WriteFile(currentDirPath, configData, 0o644)
-		suite.NoError(err)
-		defer func() { _ = os.Remove(currentDirPath) }()
-
-		// Clear existing rate limits
-		rateLimitMu.Lock()
-		rateLimits = make(map[string]RateLimitConfig)
-		rateLimitMu.Unlock()
-
-		// This should find the file in the current directory
-		err = loadRatelimitConfig()
-		suite.NoError(err)
-
-		// Verify rate limits were loaded
-		rateLimitMu.RLock()
-		defer rateLimitMu.RUnlock()
-
-		suite.Equal(2, len(rateLimits))
-	})
-
-	// Test with all files missing
-	suite.Run("all files missing", func() {
-		// Save the original load function and restore it when done
-		originalLoadFunc := loadConfigFunc
-		defer func() {
-			loadConfigFunc = originalLoadFunc
-		}()
-
-		// Replace with a mock function that always returns "file does not exist" error
-		loadConfigFunc = func(string) error {
-			return fmt.Errorf("file does not exist")
-		}
-
-		// Clear existing rate limits
-		rateLimitMu.Lock()
-		rateLimits = make(map[string]RateLimitConfig)
-		rateLimitMu.Unlock()
-
-		// This should fail as our mock returns errors for all paths
-		err = loadRatelimitConfig()
-		suite.Error(err)
-
-		// The error should be a RateLimitConfigError
-		configErr, ok := err.(*RateLimitConfigError)
-		suite.True(ok, "Expected *RateLimitConfigError but got %T", err)
-
-		// All path errors should contain our mock error message
-		for _, errMsg := range configErr.PathErrors {
-			suite.Equal("file does not exist", errMsg)
-		}
-	})
-}
-
-func (suite *Tests) Test_rateLimitedRequest() {
-	// Setup
-	cfg = &config{}
-	parseConfig()
-	cfg.Logger = libpack_logger.New()
-
-	// Create test rate limits
-	rateLimitMu.Lock()
-	rateLimits = make(map[string]RateLimitConfig)
-
-	// Admin role with high limit
-	adminCounter := goratecounter.NewRateCounter().WithConfig(goratecounter.RateCounterConfig{
-		Interval: 1 * time.Second,
-	})
-	rateLimits["admin"] = RateLimitConfig{
-		RateCounterTicker: adminCounter,
-		Interval:          1 * time.Second,
-		Req:               100,
-	}
-
-	// User role with low limit
-	userCounter := goratecounter.NewRateCounter().WithConfig(goratecounter.RateCounterConfig{
-		Interval: 1 * time.Second,
-	})
-	rateLimits["user"] = RateLimitConfig{
-		RateCounterTicker: userCounter,
-		Interval:          1 * time.Second,
-		Req:               2, // Set very low for testing
-	}
-	rateLimitMu.Unlock()
-
-	// Test non-existent role - should be denied for security
-	suite.Run("non-existent role", func() {
-		allowed := rateLimitedRequest("test-user-1", "non-existent-role")
-		suite.False(allowed, "Unknown roles should be denied for security")
-	})
-
-	// Test admin role (high limit)
-	suite.Run("admin role within limit", func() {
-		allowed := rateLimitedRequest("admin-user", "admin")
-		suite.True(allowed, "Admin should be within rate limit")
-	})
-
-	// Test user role (low limit)
-	suite.Run("user role within limit", func() {
-		// First request should be allowed
-		allowed := rateLimitedRequest("regular-user", "user")
-		suite.True(allowed, "First request should be within rate limit")
-
-		// Second request should be allowed
-		allowed = rateLimitedRequest("regular-user", "user")
-		suite.True(allowed, "Second request should be within rate limit")
-
-		// Third request should exceed limit
-		allowed = rateLimitedRequest("regular-user", "user")
-		suite.False(allowed, "Third request should exceed rate limit")
-	})
-}
-
-func (suite *Tests) Test_RateLimitConfig_UnmarshalJSON() {
-	// Test unmarshaling of string-based intervals
-	suite.Run("unmarshal string intervals", func() {
-		// Test JSON with string-based intervals
-		jsonString := `{
-			"ratelimit": {
-				"admin": {
-					"req": 100,
-					"interval": "second"
-				},
-				"guest": {
-					"req": 5,
-					"interval": "minute"
-				},
-				"user": {
-					"req": 1000,
-					"interval": "hour"
-				},
-				"service": {
-					"req": 10000,
-					"interval": "day"
-				},
-				"custom": {
-					"req": 50,
-					"interval": "5s"
-				}
-			}
-		}`
-
-		var config struct {
-			RateLimit map[string]RateLimitConfig `json:"ratelimit"`
-		}
-
-		err := json.Unmarshal([]byte(jsonString), &config)
-		suite.NoError(err)
-
-		// Verify correct parsing of intervals
-		suite.Equal(time.Second, config.RateLimit["admin"].Interval)
-		suite.Equal(time.Minute, config.RateLimit["guest"].Interval)
-		suite.Equal(time.Hour, config.RateLimit["user"].Interval)
-		suite.Equal(24*time.Hour, config.RateLimit["service"].Interval)
-		suite.Equal(5*time.Second, config.RateLimit["custom"].Interval)
-
-		// Verify req values
-		suite.Equal(100, config.RateLimit["admin"].Req)
-		suite.Equal(5, config.RateLimit["guest"].Req)
-	})
-
-	// Test unmarshaling of invalid interval formats
-	suite.Run("unmarshal invalid intervals", func() {
-		// Test with an invalid interval format
-		jsonString := `{
-			"req": 100,
-			"interval": "invalid_format"
-		}`
-
-		var config RateLimitConfig
-		err := json.Unmarshal([]byte(jsonString), &config)
-		suite.Error(err)
-		suite.Contains(err.Error(), "invalid duration format")
-	})
-
-	// Test unmarshaling of numeric intervals
-	suite.Run("unmarshal numeric intervals", func() {
-		// Test with a numeric interval (seconds)
-		jsonString := `{
-			"req": 100,
-			"interval": 60
-		}`
-
-		var config RateLimitConfig
-		err := json.Unmarshal([]byte(jsonString), &config)
-		suite.NoError(err)
-		suite.Equal(60*time.Second, config.Interval)
-	})
-}

request_coalescing.go

@@ -1,243 +0,0 @@
-package main
-
-import (
-	"sync"
-	"sync/atomic"
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-)
-
-// CoalescedResponse represents the shared response
-type CoalescedResponse struct {
-	Body       []byte
-	StatusCode int
-	Headers    map[string]string
-	Err        error
-	CachedAt   time.Time
-}
-
-// RequestCoalescer implements the single-flight pattern to deduplicate identical concurrent requests
-type RequestCoalescer struct {
-	inflight   sync.Map // key: hash, value: *inflightRequest
-	logger     *libpack_logger.Logger
-	monitoring *libpack_monitoring.MetricsSetup
-	enabled    bool
-
-	// Statistics
-	totalRequests     atomic.Int64
-	coalescedRequests atomic.Int64
-	inflightCount     atomic.Int64
-}
-
-// inflightRequest represents a request currently in flight
-type inflightRequest struct {
-	wg        sync.WaitGroup
-	response  *CoalescedResponse
-	waiters   atomic.Int32
-	createdAt time.Time
-	mu        sync.RWMutex
-}
-
-// NewRequestCoalescer creates a new request coalescer
-func NewRequestCoalescer(enabled bool, logger *libpack_logger.Logger, monitoring *libpack_monitoring.MetricsSetup) *RequestCoalescer {
-	rc := &RequestCoalescer{
-		logger:     logger,
-		monitoring: monitoring,
-		enabled:    enabled,
-	}
-
-	if logger != nil && enabled {
-		logger.Info(&libpack_logger.LogMessage{
-			Message: "Request coalescing enabled",
-		})
-	}
-
-	return rc
-}
-
-// Do executes a function, deduplicating concurrent calls with the same key
-func (rc *RequestCoalescer) Do(key string, fn func() (*CoalescedResponse, error)) (*CoalescedResponse, error) {
-	rc.totalRequests.Add(1)
-
-	if !rc.enabled {
-		return fn()
-	}
-
-	// Try to load existing inflight request
-	if existing, loaded := rc.inflight.Load(key); loaded {
-		inflight := existing.(*inflightRequest)
-
-		// Increment waiter count
-		waiters := inflight.waiters.Add(1)
-		rc.coalescedRequests.Add(1)
-
-		if rc.logger != nil {
-			rc.logger.Debug(&libpack_logger.LogMessage{
-				Message: "Request coalesced with in-flight request",
-				Pairs: map[string]interface{}{
-					"key":     key[:min(len(key), 32)] + "...",
-					"waiters": waiters,
-				},
-			})
-		}
-
-		// Wait for the inflight request to complete
-		inflight.wg.Wait()
-
-		// Return the shared response
-		inflight.mu.RLock()
-		defer inflight.mu.RUnlock()
-
-		if rc.monitoring != nil {
-			rc.monitoring.Increment("graphql_proxy_coalesced_requests_total", nil)
-		}
-
-		return inflight.response, nil
-	}
-
-	// Create a new inflight request
-	inflight := &inflightRequest{
-		createdAt: time.Now(),
-	}
-	inflight.wg.Add(1)
-	inflight.waiters.Store(1) // This request is the first waiter
-
-	// Try to store it (another goroutine might have just done the same)
-	actual, loaded := rc.inflight.LoadOrStore(key, inflight)
-	if loaded {
-		// Someone else beat us to it, wait for their result
-		existingInflight := actual.(*inflightRequest)
-		waiters := existingInflight.waiters.Add(1)
-		rc.coalescedRequests.Add(1)
-
-		if rc.logger != nil {
-			rc.logger.Debug(&libpack_logger.LogMessage{
-				Message: "Request coalesced (race condition)",
-				Pairs: map[string]interface{}{
-					"key":     key[:min(len(key), 32)] + "...",
-					"waiters": waiters,
-				},
-			})
-		}
-
-		existingInflight.wg.Wait()
-
-		existingInflight.mu.RLock()
-		defer existingInflight.mu.RUnlock()
-
-		if rc.monitoring != nil {
-			rc.monitoring.Increment("graphql_proxy_coalesced_requests_total", nil)
-		}
-
-		return existingInflight.response, nil
-	}
-
-	// We're the primary request, execute the function
-	rc.inflightCount.Add(1)
-	defer rc.inflightCount.Add(-1)
-
-	// Execute the request
-	response, err := fn()
-
-	// Store the result
-	inflight.mu.Lock()
-	if err != nil {
-		inflight.response = &CoalescedResponse{
-			Err: err,
-		}
-	} else {
-		inflight.response = response
-	}
-	inflight.mu.Unlock()
-
-	// Clean up and notify waiters
-	rc.inflight.Delete(key)
-	inflight.wg.Done()
-
-	// Log statistics
-	waiters := inflight.waiters.Load()
-	duration := time.Since(inflight.createdAt)
-
-	if rc.logger != nil && waiters > 1 {
-		rc.logger.Info(&libpack_logger.LogMessage{
-			Message: "Request completed, served coalesced waiters",
-			Pairs: map[string]interface{}{
-				"key":         key[:min(len(key), 32)] + "...",
-				"waiters":     waiters,
-				"duration_ms": duration.Milliseconds(),
-				"saved_calls": waiters - 1,
-			},
-		})
-	}
-
-	if rc.monitoring != nil {
-		rc.monitoring.Increment("graphql_proxy_primary_requests_total", nil)
-		if waiters > 1 {
-			rc.monitoring.Update("graphql_proxy_coalescing_wait_duration", nil, duration.Seconds())
-		}
-	}
-
-	return inflight.response, nil
-}
-
-// GetStats returns coalescing statistics
-func (rc *RequestCoalescer) GetStats() map[string]interface{} {
-	totalRequests := rc.totalRequests.Load()
-	coalescedRequests := rc.coalescedRequests.Load()
-
-	var coalescingRate float64
-	if totalRequests > 0 {
-		coalescingRate = float64(coalescedRequests) / float64(totalRequests) * 100
-	}
-
-	primaryRequests := totalRequests - coalescedRequests
-
-	var savings float64
-	if primaryRequests > 0 {
-		savings = float64(coalescedRequests) / float64(primaryRequests) * 100
-	}
-
-	return map[string]interface{}{
-		"enabled":             rc.enabled,
-		"total_requests":      totalRequests,
-		"primary_requests":    primaryRequests,
-		"coalesced_requests":  coalescedRequests,
-		"inflight_count":      rc.inflightCount.Load(),
-		"coalescing_rate_pct": coalescingRate,
-		"backend_savings_pct": savings,
-	}
-}
-
-// Reset resets coalescing statistics
-func (rc *RequestCoalescer) Reset() {
-	rc.totalRequests.Store(0)
-	rc.coalescedRequests.Store(0)
-}
-
-// Global request coalescer
-var (
-	requestCoalescer     *RequestCoalescer
-	requestCoalescerOnce sync.Once
-)
-
-// InitializeRequestCoalescer initializes the global request coalescer
-func InitializeRequestCoalescer(enabled bool, logger *libpack_logger.Logger, monitoring *libpack_monitoring.MetricsSetup) *RequestCoalescer {
-	requestCoalescerOnce.Do(func() {
-		requestCoalescer = NewRequestCoalescer(enabled, logger, monitoring)
-	})
-	return requestCoalescer
-}
-
-// GetRequestCoalescer returns the global request coalescer
-func GetRequestCoalescer() *RequestCoalescer {
-	return requestCoalescer
-}
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

request_coalescing_test.go

@@ -1,407 +0,0 @@
-package main
-
-import (
-	"errors"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewRequestCoalescer(t *testing.T) {
-	tests := []struct {
-		name    string
-		enabled bool
-	}{
-		{
-			name:    "enabled coalescer",
-			enabled: true,
-		},
-		{
-			name:    "disabled coalescer",
-			enabled: false,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger := libpack_logger.New()
-			monitoring := libpack_monitoring.NewMonitoring(&libpack_monitoring.InitConfig{})
-
-			rc := NewRequestCoalescer(tt.enabled, logger, monitoring)
-
-			assert.NotNil(t, rc)
-			assert.Equal(t, tt.enabled, rc.enabled)
-		})
-	}
-}
-
-func TestRequestCoalescer_Do_SingleRequest(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	executed := false
-	response := &CoalescedResponse{
-		Body:       []byte("test response"),
-		StatusCode: 200,
-	}
-
-	fn := func() (*CoalescedResponse, error) {
-		executed = true
-		return response, nil
-	}
-
-	result, err := rc.Do("test-key", fn)
-
-	assert.NoError(t, err)
-	assert.True(t, executed)
-	assert.Equal(t, response, result)
-
-	stats := rc.GetStats()
-	assert.Equal(t, int64(1), stats["total_requests"])
-	assert.Equal(t, int64(1), stats["primary_requests"])
-	assert.Equal(t, int64(0), stats["coalesced_requests"])
-}
-
-func TestRequestCoalescer_Do_ConcurrentRequests(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	var executionCount atomic.Int32
-	response := &CoalescedResponse{
-		Body:       []byte("test response"),
-		StatusCode: 200,
-	}
-
-	fn := func() (*CoalescedResponse, error) {
-		executionCount.Add(1)
-		time.Sleep(50 * time.Millisecond) // Simulate work
-		return response, nil
-	}
-
-	// Launch concurrent requests with the same key
-	concurrentRequests := 10
-	var wg sync.WaitGroup
-	wg.Add(concurrentRequests)
-
-	results := make([]*CoalescedResponse, concurrentRequests)
-	errs := make([]error, concurrentRequests)
-
-	for i := 0; i < concurrentRequests; i++ {
-		go func(index int) {
-			defer wg.Done()
-			results[index], errs[index] = rc.Do("same-key", fn)
-		}(i)
-	}
-
-	wg.Wait()
-
-	// Function should only execute once
-	assert.Equal(t, int32(1), executionCount.Load())
-
-	// All requests should get the same response
-	for i := 0; i < concurrentRequests; i++ {
-		assert.NoError(t, errs[i])
-		assert.Equal(t, response, results[i])
-	}
-
-	stats := rc.GetStats()
-	assert.Equal(t, int64(concurrentRequests), stats["total_requests"])
-	assert.Equal(t, int64(1), stats["primary_requests"])
-	assert.Equal(t, int64(concurrentRequests-1), stats["coalesced_requests"])
-
-	// Check backend savings
-	backendSavings := stats["backend_savings_pct"].(float64)
-	assert.Greater(t, backendSavings, 0.0)
-}
-
-func TestRequestCoalescer_Do_DifferentKeys(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	var executionCount atomic.Int32
-
-	fn := func() (*CoalescedResponse, error) {
-		executionCount.Add(1)
-		return &CoalescedResponse{Body: []byte("response")}, nil
-	}
-
-	// Concurrent requests with different keys
-	var wg sync.WaitGroup
-	keys := []string{"key1", "key2", "key3"}
-
-	for _, key := range keys {
-		wg.Add(1)
-		go func(k string) {
-			defer wg.Done()
-			rc.Do(k, fn)
-		}(key)
-	}
-
-	wg.Wait()
-
-	// Function should execute for each unique key
-	assert.Equal(t, int32(len(keys)), executionCount.Load())
-
-	stats := rc.GetStats()
-	assert.Equal(t, int64(3), stats["primary_requests"])
-	assert.Equal(t, int64(0), stats["coalesced_requests"])
-}
-
-func TestRequestCoalescer_Do_Error(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	expectedErr := errors.New("test error")
-
-	fn := func() (*CoalescedResponse, error) {
-		return nil, expectedErr
-	}
-
-	result, err := rc.Do("error-key", fn)
-
-	assert.NoError(t, err)
-	assert.NotNil(t, result)
-	assert.Error(t, result.Err)
-	assert.Equal(t, expectedErr, result.Err)
-}
-
-func TestRequestCoalescer_Do_ConcurrentWithError(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	expectedErr := errors.New("test error")
-	var executionCount atomic.Int32
-
-	fn := func() (*CoalescedResponse, error) {
-		executionCount.Add(1)
-		time.Sleep(50 * time.Millisecond)
-		return nil, expectedErr
-	}
-
-	// Launch concurrent requests
-	concurrentRequests := 5
-	var wg sync.WaitGroup
-	wg.Add(concurrentRequests)
-
-	results := make([]*CoalescedResponse, concurrentRequests)
-
-	for i := 0; i < concurrentRequests; i++ {
-		go func(index int) {
-			defer wg.Done()
-			results[index], _ = rc.Do("error-key", fn)
-		}(i)
-	}
-
-	wg.Wait()
-
-	// Function should only execute once
-	assert.Equal(t, int32(1), executionCount.Load())
-
-	// All requests should get the same error in response
-	for i := 0; i < concurrentRequests; i++ {
-		assert.NotNil(t, results[i])
-		assert.Error(t, results[i].Err)
-		assert.Equal(t, expectedErr, results[i].Err)
-	}
-}
-
-func TestRequestCoalescer_Do_Disabled(t *testing.T) {
-	rc := NewRequestCoalescer(false, libpack_logger.New(), nil)
-
-	var executionCount atomic.Int32
-
-	fn := func() (*CoalescedResponse, error) {
-		executionCount.Add(1)
-		return &CoalescedResponse{Body: []byte("response")}, nil
-	}
-
-	// Launch concurrent requests with the same key
-	concurrentRequests := 5
-	var wg sync.WaitGroup
-	wg.Add(concurrentRequests)
-
-	for i := 0; i < concurrentRequests; i++ {
-		go func() {
-			defer wg.Done()
-			rc.Do("same-key", fn)
-		}()
-	}
-
-	wg.Wait()
-
-	// When disabled, function should execute for each request
-	assert.Equal(t, int32(concurrentRequests), executionCount.Load())
-
-	stats := rc.GetStats()
-	assert.Equal(t, false, stats["enabled"])
-}
-
-func TestRequestCoalescer_GetStats(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	fn := func() (*CoalescedResponse, error) {
-		time.Sleep(10 * time.Millisecond)
-		return &CoalescedResponse{Body: []byte("response")}, nil
-	}
-
-	// Simulate some coalesced requests
-	var wg sync.WaitGroup
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			rc.Do("key1", fn)
-		}()
-	}
-	wg.Wait()
-
-	// Add some non-coalesced requests
-	rc.Do("key2", fn)
-	rc.Do("key3", fn)
-
-	stats := rc.GetStats()
-
-	assert.Equal(t, true, stats["enabled"])
-	assert.Equal(t, int64(12), stats["total_requests"])
-	assert.Equal(t, int64(3), stats["primary_requests"])
-	assert.Equal(t, int64(9), stats["coalesced_requests"])
-	assert.Equal(t, int64(0), stats["inflight_count"])
-
-	coalescingRate := stats["coalescing_rate_pct"].(float64)
-	assert.Greater(t, coalescingRate, 0.0)
-	assert.LessOrEqual(t, coalescingRate, 100.0)
-
-	backendSavings := stats["backend_savings_pct"].(float64)
-	assert.Greater(t, backendSavings, 0.0)
-}
-
-func TestRequestCoalescer_Reset(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	fn := func() (*CoalescedResponse, error) {
-		return &CoalescedResponse{Body: []byte("response")}, nil
-	}
-
-	// Generate some activity
-	rc.Do("key1", fn)
-	rc.Do("key2", fn)
-
-	statsBefore := rc.GetStats()
-	assert.Greater(t, statsBefore["total_requests"].(int64), int64(0))
-
-	// Reset
-	rc.Reset()
-
-	statsAfter := rc.GetStats()
-	assert.Equal(t, int64(0), statsAfter["total_requests"])
-	assert.Equal(t, int64(0), statsAfter["primary_requests"])
-	assert.Equal(t, int64(0), statsAfter["coalesced_requests"])
-}
-
-func TestRequestCoalescer_RaceCondition(t *testing.T) {
-	rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-	var executionCount atomic.Int32
-
-	fn := func() (*CoalescedResponse, error) {
-		executionCount.Add(1)
-		time.Sleep(5 * time.Millisecond)
-		return &CoalescedResponse{Body: []byte("response")}, nil
-	}
-
-	// Launch many concurrent requests in waves
-	waves := 5
-	requestsPerWave := 20
-
-	for wave := 0; wave < waves; wave++ {
-		var wg sync.WaitGroup
-		wg.Add(requestsPerWave)
-
-		for i := 0; i < requestsPerWave; i++ {
-			go func() {
-				defer wg.Done()
-				rc.Do("race-key", fn)
-			}()
-		}
-
-		wg.Wait()
-		time.Sleep(10 * time.Millisecond) // Small delay between waves
-	}
-
-	// Execution count should be much less than total requests
-	totalRequests := waves * requestsPerWave
-	assert.Less(t, int(executionCount.Load()), totalRequests)
-
-	stats := rc.GetStats()
-	assert.Equal(t, int64(totalRequests), stats["total_requests"])
-}
-
-func TestRequestCoalescer_BackendSavingsCalculation(t *testing.T) {
-	tests := []struct {
-		name              string
-		totalRequests     int64
-		coalescedRequests int64
-		expectedSavings   float64
-	}{
-		{
-			name:              "50% savings",
-			totalRequests:     100,
-			coalescedRequests: 50,
-			expectedSavings:   100.0, // 50 coalesced / 50 primary = 100%
-		},
-		{
-			name:              "90% savings",
-			totalRequests:     100,
-			coalescedRequests: 90,
-			expectedSavings:   900.0, // 90 coalesced / 10 primary = 900%
-		},
-		{
-			name:              "no savings",
-			totalRequests:     100,
-			coalescedRequests: 0,
-			expectedSavings:   0.0,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			rc := NewRequestCoalescer(true, libpack_logger.New(), nil)
-
-			rc.totalRequests.Store(tt.totalRequests)
-			rc.coalescedRequests.Store(tt.coalescedRequests)
-
-			stats := rc.GetStats()
-			savings := stats["backend_savings_pct"].(float64)
-
-			assert.InDelta(t, tt.expectedSavings, savings, 0.1)
-		})
-	}
-}
-
-func TestRequestCoalescer_GlobalInstance(t *testing.T) {
-	rc := InitializeRequestCoalescer(true, libpack_logger.New(), nil)
-	assert.NotNil(t, rc)
-
-	// Should return the same instance
-	rc2 := GetRequestCoalescer()
-	assert.Equal(t, rc, rc2)
-}
-
-func TestMin(t *testing.T) {
-	tests := []struct {
-		a        int
-		b        int
-		expected int
-	}{
-		{a: 5, b: 10, expected: 5},
-		{a: 10, b: 5, expected: 5},
-		{a: 5, b: 5, expected: 5},
-		{a: 0, b: 10, expected: 0},
-		{a: -5, b: 5, expected: -5},
-	}
-
-	for _, tt := range tests {
-		result := min(tt.a, tt.b)
-		assert.Equal(t, tt.expected, result)
-	}
-}

retry_budget.go

@@ -1,238 +0,0 @@
-package main
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-// RetryBudget implements a token bucket algorithm to limit the rate of retries
-// This prevents retry storms and cascading failures
-type RetryBudget struct {
-	tokensPerSecond float64
-	maxTokens       int64
-	currentTokens   atomic.Int64
-	lastRefill      atomic.Int64 // Unix timestamp in nanoseconds
-	mu              sync.RWMutex
-	enabled         bool
-	logger          *libpack_logger.Logger
-	ctx             context.Context
-	cancel          context.CancelFunc
-
-	// Statistics
-	totalAttempts  atomic.Int64
-	allowedRetries atomic.Int64
-	deniedRetries  atomic.Int64
-}
-
-// RetryBudgetConfig holds configuration for retry budget
-type RetryBudgetConfig struct {
-	TokensPerSecond float64 // Rate at which tokens are refilled
-	MaxTokens       int     // Maximum number of tokens (burst capacity)
-	Enabled         bool    // Whether retry budget is enabled
-}
-
-// NewRetryBudget creates a new retry budget (deprecated, use NewRetryBudgetWithContext)
-func NewRetryBudget(config RetryBudgetConfig, logger *libpack_logger.Logger) *RetryBudget {
-	return NewRetryBudgetWithContext(context.Background(), config, logger)
-}
-
-// NewRetryBudgetWithContext creates a new retry budget with context for graceful shutdown
-func NewRetryBudgetWithContext(ctx context.Context, config RetryBudgetConfig, logger *libpack_logger.Logger) *RetryBudget {
-	budgetCtx, cancel := context.WithCancel(ctx)
-	rb := &RetryBudget{
-		tokensPerSecond: config.TokensPerSecond,
-		maxTokens:       int64(config.MaxTokens),
-		enabled:         config.Enabled,
-		logger:          logger,
-		ctx:             budgetCtx,
-		cancel:          cancel,
-	}
-
-	// Initialize with full bucket
-	rb.currentTokens.Store(rb.maxTokens)
-	rb.lastRefill.Store(time.Now().UnixNano())
-
-	// Start refill goroutine
-	if rb.enabled {
-		go rb.refillLoop()
-	}
-
-	return rb
-}
-
-// AllowRetry checks if a retry is allowed based on the current budget
-func (rb *RetryBudget) AllowRetry() bool {
-	rb.totalAttempts.Add(1)
-
-	if !rb.enabled {
-		rb.allowedRetries.Add(1)
-		return true
-	}
-
-	// Try to consume a token
-	for {
-		current := rb.currentTokens.Load()
-		if current <= 0 {
-			rb.deniedRetries.Add(1)
-			if rb.logger != nil {
-				rb.logger.Debug(&libpack_logger.LogMessage{
-					Message: "Retry denied: budget exhausted",
-					Pairs: map[string]interface{}{
-						"current_tokens": current,
-						"denied_count":   rb.deniedRetries.Load(),
-					},
-				})
-			}
-			return false
-		}
-
-		if rb.currentTokens.CompareAndSwap(current, current-1) {
-			rb.allowedRetries.Add(1)
-			return true
-		}
-	}
-}
-
-// refillLoop periodically refills tokens
-func (rb *RetryBudget) refillLoop() {
-	ticker := time.NewTicker(100 * time.Millisecond) // Refill every 100ms
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-rb.ctx.Done():
-			return
-		case <-ticker.C:
-			rb.refill()
-		}
-	}
-}
-
-// Shutdown stops the retry budget goroutine
-func (rb *RetryBudget) Shutdown() {
-	if rb.cancel != nil {
-		rb.cancel()
-	}
-}
-
-// refill adds tokens to the bucket based on elapsed time
-func (rb *RetryBudget) refill() {
-	now := time.Now().UnixNano()
-	last := rb.lastRefill.Load()
-
-	// Calculate elapsed time in seconds
-	elapsed := float64(now-last) / float64(time.Second)
-
-	// Calculate tokens to add
-	tokensToAdd := int64(elapsed * rb.tokensPerSecond)
-
-	if tokensToAdd > 0 {
-		// Update last refill time
-		if rb.lastRefill.CompareAndSwap(last, now) {
-			// Add tokens, capped at maxTokens
-			for {
-				current := rb.currentTokens.Load()
-				newValue := current + tokensToAdd
-				if newValue > rb.maxTokens {
-					newValue = rb.maxTokens
-				}
-
-				if rb.currentTokens.CompareAndSwap(current, newValue) {
-					break
-				}
-			}
-		}
-	}
-}
-
-// GetStats returns current statistics
-func (rb *RetryBudget) GetStats() map[string]interface{} {
-	totalAttempts := rb.totalAttempts.Load()
-	allowedRetries := rb.allowedRetries.Load()
-	deniedRetries := rb.deniedRetries.Load()
-
-	var denialRate float64
-	if totalAttempts > 0 {
-		denialRate = float64(deniedRetries) / float64(totalAttempts) * 100
-	}
-
-	return map[string]interface{}{
-		"enabled":         rb.enabled,
-		"current_tokens":  rb.currentTokens.Load(),
-		"max_tokens":      rb.maxTokens,
-		"tokens_per_sec":  rb.tokensPerSecond,
-		"total_attempts":  totalAttempts,
-		"allowed_retries": allowedRetries,
-		"denied_retries":  deniedRetries,
-		"denial_rate_pct": denialRate,
-	}
-}
-
-// Reset resets the retry budget statistics
-func (rb *RetryBudget) Reset() {
-	rb.totalAttempts.Store(0)
-	rb.allowedRetries.Store(0)
-	rb.deniedRetries.Store(0)
-	rb.currentTokens.Store(rb.maxTokens)
-}
-
-// UpdateConfig updates the retry budget configuration
-func (rb *RetryBudget) UpdateConfig(config RetryBudgetConfig) {
-	rb.mu.Lock()
-	defer rb.mu.Unlock()
-
-	rb.tokensPerSecond = config.TokensPerSecond
-	rb.maxTokens = int64(config.MaxTokens)
-	rb.enabled = config.Enabled
-
-	// Reset to full capacity
-	rb.currentTokens.Store(rb.maxTokens)
-
-	if rb.logger != nil {
-		rb.logger.Info(&libpack_logger.LogMessage{
-			Message: "Retry budget configuration updated",
-			Pairs: map[string]interface{}{
-				"tokens_per_sec": config.TokensPerSecond,
-				"max_tokens":     config.MaxTokens,
-				"enabled":        config.Enabled,
-			},
-		})
-	}
-}
-
-// Global retry budget instance
-var (
-	retryBudget     *RetryBudget
-	retryBudgetOnce sync.Once
-)
-
-// InitializeRetryBudget initializes the global retry budget (deprecated, use InitializeRetryBudgetWithContext)
-func InitializeRetryBudget(config RetryBudgetConfig, logger *libpack_logger.Logger) *RetryBudget {
-	return InitializeRetryBudgetWithContext(context.Background(), config, logger)
-}
-
-// InitializeRetryBudgetWithContext initializes the global retry budget with context for graceful shutdown
-func InitializeRetryBudgetWithContext(ctx context.Context, config RetryBudgetConfig, logger *libpack_logger.Logger) *RetryBudget {
-	retryBudgetOnce.Do(func() {
-		retryBudget = NewRetryBudgetWithContext(ctx, config, logger)
-		if logger != nil && config.Enabled {
-			logger.Info(&libpack_logger.LogMessage{
-				Message: "Retry budget initialized",
-				Pairs: map[string]interface{}{
-					"tokens_per_sec": config.TokensPerSecond,
-					"max_tokens":     config.MaxTokens,
-				},
-			})
-		}
-	})
-	return retryBudget
-}
-
-// GetRetryBudget returns the global retry budget instance
-func GetRetryBudget() *RetryBudget {
-	return retryBudget
-}

retry_budget_test.go

@@ -1,312 +0,0 @@
-package main
-
-import (
-	"testing"
-	"time"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/assert"
-)
-
-func TestNewRetryBudget(t *testing.T) {
-	tests := []struct {
-		name   string
-		config RetryBudgetConfig
-	}{
-		{
-			name: "default config",
-			config: RetryBudgetConfig{
-				TokensPerSecond: 10.0,
-				MaxTokens:       100,
-				Enabled:         true,
-			},
-		},
-		{
-			name: "custom config",
-			config: RetryBudgetConfig{
-				TokensPerSecond: 50.0,
-				MaxTokens:       500,
-				Enabled:         true,
-			},
-		},
-		{
-			name: "disabled config",
-			config: RetryBudgetConfig{
-				TokensPerSecond: 10.0,
-				MaxTokens:       100,
-				Enabled:         false,
-			},
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			logger := libpack_logger.New()
-
-			rb := NewRetryBudget(tt.config, logger)
-
-			assert.NotNil(t, rb)
-			assert.Equal(t, tt.config.Enabled, rb.enabled)
-			assert.Equal(t, tt.config.TokensPerSecond, rb.tokensPerSecond)
-			assert.Equal(t, int64(tt.config.MaxTokens), rb.maxTokens)
-
-			if tt.config.Enabled {
-				// Should start with max tokens
-				assert.Equal(t, int64(tt.config.MaxTokens), rb.currentTokens.Load())
-			}
-		})
-	}
-}
-
-func TestRetryBudget_Allow(t *testing.T) {
-	t.Run("allow when enabled and tokens available", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 10.0,
-			MaxTokens:       100,
-			Enabled:         true,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		// Should allow first request
-		allowed := rb.AllowRetry()
-		assert.True(t, allowed)
-
-		// Tokens should be decremented
-		assert.Less(t, rb.currentTokens.Load(), int64(100))
-	})
-
-	t.Run("deny when tokens exhausted", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 10.0,
-			MaxTokens:       2,
-			Enabled:         true,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		// Consume all tokens
-		assert.True(t, rb.AllowRetry())
-		assert.True(t, rb.AllowRetry())
-
-		// Should deny when exhausted
-		assert.False(t, rb.AllowRetry())
-
-		stats := rb.GetStats()
-		assert.Greater(t, stats["denied_retries"].(int64), int64(0))
-	})
-
-	t.Run("always allow when disabled", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 10.0,
-			MaxTokens:       0,
-			Enabled:         false,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		// Should always allow when disabled
-		for i := 0; i < 100; i++ {
-			assert.True(t, rb.AllowRetry())
-		}
-	})
-}
-
-func TestRetryBudget_Refill(t *testing.T) {
-	t.Run("tokens refill over time", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 100.0, // Fast refill for testing
-			MaxTokens:       100,
-			Enabled:         true,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		// Consume some tokens
-		for i := 0; i < 50; i++ {
-			rb.AllowRetry()
-		}
-
-		tokensBefore := rb.currentTokens.Load()
-
-		// Wait for refill (multiple refill cycles at 100ms each)
-		time.Sleep(300 * time.Millisecond)
-
-		tokensAfter := rb.currentTokens.Load()
-
-		// Tokens should have increased
-		assert.Greater(t, tokensAfter, tokensBefore)
-	})
-
-	t.Run("tokens don't exceed max", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 100.0,
-			MaxTokens:       50,
-			Enabled:         true,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		// Wait for potential overflow
-		time.Sleep(200 * time.Millisecond)
-
-		tokens := rb.currentTokens.Load()
-		assert.LessOrEqual(t, tokens, int64(50))
-	})
-}
-
-func TestRetryBudget_GetStats(t *testing.T) {
-	t.Run("tracks statistics correctly", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 10.0,
-			MaxTokens:       5,
-			Enabled:         true,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		// Allow some requests
-		rb.AllowRetry()
-		rb.AllowRetry()
-		rb.AllowRetry()
-
-		// Consume all tokens to trigger denials
-		rb.AllowRetry()
-		rb.AllowRetry()
-		rb.AllowRetry() // Should be denied
-		rb.AllowRetry() // Should be denied
-
-		stats := rb.GetStats()
-
-		assert.Equal(t, true, stats["enabled"])
-		assert.Equal(t, 10.0, stats["tokens_per_sec"])
-		assert.Equal(t, int64(5), stats["max_tokens"])
-		assert.GreaterOrEqual(t, stats["current_tokens"].(int64), int64(0))
-		assert.Equal(t, int64(7), stats["total_attempts"])
-		assert.GreaterOrEqual(t, stats["denied_retries"].(int64), int64(2))
-		assert.Greater(t, stats["denial_rate_pct"].(float64), 0.0)
-	})
-
-	t.Run("stats when disabled", func(t *testing.T) {
-		config := RetryBudgetConfig{
-			TokensPerSecond: 10.0,
-			MaxTokens:       100,
-			Enabled:         false,
-		}
-
-		rb := NewRetryBudget(config, libpack_logger.New())
-
-		stats := rb.GetStats()
-
-		assert.Equal(t, false, stats["enabled"])
-		assert.Equal(t, int64(0), stats["total_attempts"])
-		assert.Equal(t, int64(0), stats["denied_retries"])
-	})
-}
-
-func TestRetryBudget_Reset(t *testing.T) {
-	config := RetryBudgetConfig{
-		TokensPerSecond: 10.0,
-		MaxTokens:       10,
-		Enabled:         true,
-	}
-
-	rb := NewRetryBudget(config, libpack_logger.New())
-
-	// Generate some activity
-	for i := 0; i < 15; i++ {
-		rb.AllowRetry()
-	}
-
-	statsBefore := rb.GetStats()
-	assert.Greater(t, statsBefore["total_attempts"].(int64), int64(0))
-
-	// Reset
-	rb.Reset()
-
-	statsAfter := rb.GetStats()
-	assert.Equal(t, int64(0), statsAfter["total_attempts"])
-	assert.Equal(t, int64(0), statsAfter["denied_retries"])
-	assert.Equal(t, int64(10), statsAfter["current_tokens"]) // Should reset to max
-}
-
-func TestRetryBudget_ConcurrentAccess(t *testing.T) {
-	config := RetryBudgetConfig{
-		TokensPerSecond: 100.0,
-		MaxTokens:       1000,
-		Enabled:         true,
-	}
-
-	rb := NewRetryBudget(config, libpack_logger.New())
-
-	// Concurrent access test
-	done := make(chan bool)
-	goroutines := 100
-	requestsPerGoroutine := 10
-
-	for i := 0; i < goroutines; i++ {
-		go func() {
-			for j := 0; j < requestsPerGoroutine; j++ {
-				rb.AllowRetry()
-			}
-			done <- true
-		}()
-	}
-
-	// Wait for all goroutines
-	for i := 0; i < goroutines; i++ {
-		<-done
-	}
-
-	stats := rb.GetStats()
-	totalAttempts := stats["total_attempts"].(int64)
-
-	// Should have processed all requests
-	assert.Equal(t, int64(goroutines*requestsPerGoroutine), totalAttempts)
-}
-
-func TestRetryBudget_DenialRate(t *testing.T) {
-	config := RetryBudgetConfig{
-		TokensPerSecond: 1.0,
-		MaxTokens:       10,
-		Enabled:         true,
-	}
-
-	rb := NewRetryBudget(config, libpack_logger.New())
-
-	// Consume all tokens
-	for i := 0; i < 10; i++ {
-		rb.AllowRetry()
-	}
-
-	// These should be denied
-	deniedCount := 0
-	for i := 0; i < 10; i++ {
-		if !rb.AllowRetry() {
-			deniedCount++
-		}
-	}
-
-	assert.Greater(t, deniedCount, 0)
-
-	stats := rb.GetStats()
-	denialRate := stats["denial_rate_pct"].(float64)
-
-	assert.Greater(t, denialRate, 0.0)
-	assert.LessOrEqual(t, denialRate, 100.0)
-}
-
-func TestRetryBudget_GlobalInstance(t *testing.T) {
-	config := RetryBudgetConfig{
-		TokensPerSecond: 10.0,
-		MaxTokens:       100,
-		Enabled:         true,
-	}
-
-	rb := InitializeRetryBudget(config, libpack_logger.New())
-	assert.NotNil(t, rb)
-
-	// Should return the same instance
-	rb2 := GetRetryBudget()
-	assert.Equal(t, rb, rb2)
-}

rps_tracker.go

@@ -1,108 +0,0 @@
-package main
-
-import (
-	"context"
-	"sync"
-	"sync/atomic"
-	"time"
-)
-
-// RPSTracker tracks requests per second using periodic sampling
-type RPSTracker struct {
-	lastCount      atomic.Int64
-	lastSampleTime atomic.Int64 // Unix nano
-	currentRPS     uint64       // stored as uint64, accessed with atomic operations
-	mu             sync.RWMutex // for currentRPS updates
-	ctx            context.Context
-	cancel         context.CancelFunc
-}
-
-// NewRPSTracker creates a new RPS tracker with context for graceful shutdown
-func NewRPSTracker(ctx context.Context) *RPSTracker {
-	trackerCtx, cancel := context.WithCancel(ctx)
-	tracker := &RPSTracker{
-		ctx:    trackerCtx,
-		cancel: cancel,
-	}
-	tracker.lastSampleTime.Store(time.Now().UnixNano())
-	go tracker.updateLoop()
-	return tracker
-}
-
-// RecordRequest increments the request counter
-func (r *RPSTracker) RecordRequest() {
-	// Just increment the counter, sampling happens in background
-	r.lastCount.Add(1)
-}
-
-// updateLoop periodically calculates current RPS
-func (r *RPSTracker) updateLoop() {
-	ticker := time.NewTicker(1 * time.Second)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-r.ctx.Done():
-			return
-		case <-ticker.C:
-			r.sample()
-		}
-	}
-}
-
-// Shutdown stops the RPS tracker
-func (r *RPSTracker) Shutdown() {
-	if r.cancel != nil {
-		r.cancel()
-	}
-}
-
-// sample calculates RPS since last sample
-func (r *RPSTracker) sample() {
-	now := time.Now()
-	nowNano := now.UnixNano()
-
-	currentCount := r.lastCount.Load()
-	lastSampleNano := r.lastSampleTime.Load()
-
-	if lastSampleNano == 0 {
-		r.lastSampleTime.Store(nowNano)
-		return
-	}
-
-	elapsed := float64(nowNano-lastSampleNano) / float64(time.Second)
-	if elapsed > 0 {
-		rps := float64(currentCount) / elapsed
-		// Store RPS as centirps for precision (multiply by 100)
-		r.mu.Lock()
-		atomic.StoreUint64(&r.currentRPS, uint64(rps*100))
-		r.mu.Unlock()
-	}
-
-	// Reset for next sample
-	r.lastCount.Store(0)
-	r.lastSampleTime.Store(nowNano)
-}
-
-// GetCurrentRPS returns the current requests per second
-func (r *RPSTracker) GetCurrentRPS() float64 {
-	r.mu.RLock()
-	centirps := atomic.LoadUint64(&r.currentRPS)
-	r.mu.RUnlock()
-	return float64(centirps) / 100.0
-}
-
-var globalRPSTracker *RPSTracker
-
-// InitializeRPSTracker initializes the global RPS tracker with context for graceful shutdown
-func InitializeRPSTracker(ctx context.Context) *RPSTracker {
-	if globalRPSTracker == nil {
-		globalRPSTracker = NewRPSTracker(ctx)
-	}
-	return globalRPSTracker
-}
-
-// GetRPSTracker returns the global RPS tracker
-func GetRPSTracker() *RPSTracker {
-	return globalRPSTracker
-}

safe_uint32_test.go

@@ -1,215 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"math"
-	"strings"
-	"testing"
-
-	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/suite"
-)
-
-// SafeUint32TestSuite is a test suite for safe integer conversion functionality
-type SafeUint32TestSuite struct {
-	suite.Suite
-	originalConfig *config
-	outputBuffer   *bytes.Buffer // Used to capture logger output
-}
-
-func (suite *SafeUint32TestSuite) SetupTest() {
-
-	// Store original config to restore later
-	suite.originalConfig = cfg
-
-	// Create a buffer to capture logger output
-	suite.outputBuffer = &bytes.Buffer{}
-
-	// Setup a new config with a real logger that writes to our buffer
-	cfg = &config{}
-	cfg.Logger = libpack_logger.New().SetOutput(suite.outputBuffer)
-}
-
-func (suite *SafeUint32TestSuite) TearDownTest() {
-	// Restore original config
-	cfg = suite.originalConfig
-}
-
-// Helper function to check if a specific message appears in the logger output
-func (suite *SafeUint32TestSuite) logContains(substring string) bool {
-	return strings.Contains(suite.outputBuffer.String(), substring)
-}
-
-// TestSafeUint32 tests the safeUint32 function with various input values
-func (suite *SafeUint32TestSuite) TestSafeUint32() {
-	testCases := []struct {
-		name     string
-		input    int
-		expected uint32
-	}{
-		{
-			name:     "negative value",
-			input:    -10,
-			expected: 0,
-		},
-		{
-			name:     "zero value",
-			input:    0,
-			expected: 0,
-		},
-		{
-			name:     "small positive value",
-			input:    42,
-			expected: 42,
-		},
-		{
-			name:     "maximum uint32 value",
-			input:    math.MaxUint32,
-			expected: math.MaxUint32,
-		},
-		{
-			name:     "value exceeding uint32 maximum",
-			input:    math.MaxUint32 + 1,
-			expected: math.MaxUint32,
-		},
-		{
-			name:     "large negative value",
-			input:    -1000000,
-			expected: 0,
-		},
-	}
-
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			result := safeUint32(tc.input)
-			suite.Equal(tc.expected, result, fmt.Sprintf("safeUint32(%d) should return %d", tc.input, tc.expected))
-		})
-	}
-}
-
-// TestSafeMaxRequests tests the safeMaxRequests function
-func (suite *SafeUint32TestSuite) TestSafeMaxRequests() {
-	testCases := []struct {
-		name           string
-		warningMessage string
-		input          int
-		expected       uint32
-		expectWarning  bool
-	}{
-		{
-			name:           "negative value",
-			input:          -10,
-			expected:       uint32(defaultMaxRequestsInHalfOpen),
-			expectWarning:  true,
-			warningMessage: "Invalid MaxRequestsInHalfOpen value, using default",
-		},
-		{
-			name:          "zero value",
-			input:         0,
-			expected:      0,
-			expectWarning: false,
-		},
-		{
-			name:          "normal value",
-			input:         5,
-			expected:      5,
-			expectWarning: false,
-		},
-		{
-			name:           "value exceeding uint32 maximum",
-			input:          math.MaxUint32 + 1,
-			expected:       uint32(defaultMaxRequestsInHalfOpen),
-			expectWarning:  true,
-			warningMessage: "Invalid MaxRequestsInHalfOpen value, using default",
-		},
-		{
-			name:          "value at uint32 maximum",
-			input:         math.MaxUint32,
-			expected:      math.MaxUint32,
-			expectWarning: false,
-		},
-	}
-
-	for _, tc := range testCases {
-		suite.Run(tc.name, func() {
-			// Reset the logger buffer before each test case
-			suite.outputBuffer.Reset()
-
-			// Call function
-			result := safeMaxRequests(tc.input)
-
-			// Verify result
-			suite.Equal(tc.expected, result, fmt.Sprintf("safeMaxRequests(%d) should return %d", tc.input, tc.expected))
-
-			// Verify logging behavior
-			if tc.expectWarning {
-				suite.True(suite.logContains(tc.warningMessage), "Expected warning message not found in logs")
-				suite.True(suite.logContains(fmt.Sprintf(`"requested_value":%d`, tc.input)), "Requested value not found in warning log")
-				suite.True(suite.logContains(fmt.Sprintf(`"default_value":%d`, defaultMaxRequestsInHalfOpen)), "Default value not found in warning log")
-			} else {
-				suite.False(suite.logContains("Invalid MaxRequestsInHalfOpen value"), "Unexpected warning message found in logs")
-			}
-		})
-	}
-}
-
-// TestSafeMaxRequestsWithNilLogger tests safeMaxRequests when the logger is nil
-func (suite *SafeUint32TestSuite) TestSafeMaxRequestsWithNilLogger() {
-	// Save the current logger
-	originalLogger := cfg.Logger
-
-	// Set logger to nil
-	cfg.Logger = nil
-
-	// Test with values that would normally trigger a warning
-	result := safeMaxRequests(-5)
-	suite.Equal(uint32(defaultMaxRequestsInHalfOpen), result, "Even with nil logger, function should return default value for invalid input")
-
-	// Restore the logger
-	cfg.Logger = originalLogger
-}
-
-// TestCircuitBreakerWithSafeValues tests that the circuit breaker correctly uses the safe functions
-func (suite *SafeUint32TestSuite) TestCircuitBreakerWithSafeValues() {
-	// Skip circuit breaker integration test since we're only testing the safe conversion functions
-	// This avoids the need to fully mock the monitoring system
-
-	// Just test the trip function logic directly
-	cfg.CircuitBreaker.MaxFailures = -1 // Negative value should be converted to 0 by safeUint32
-
-	// Call safeUint32 directly to verify it handles negative value
-	safeValue := safeUint32(cfg.CircuitBreaker.MaxFailures)
-	suite.Equal(uint32(0), safeValue, "safeUint32 should convert negative value to 0")
-
-	// A ConsecutiveFailures count of 1 should be >= safeUint32(-1) which is 0
-	suite.True(uint32(1) >= safeValue, "1 should be >= safeUint32(negative value)")
-
-	// Test with excessive MaxRequestsInHalfOpen directly
-	excessiveValue := math.MaxUint32 + 1
-
-	// Reset the logger buffer to verify warning
-	suite.outputBuffer.Reset()
-
-	// Call safeMaxRequests directly
-	maxRequests := safeMaxRequests(excessiveValue)
-
-	// Verify the result
-	suite.Equal(uint32(defaultMaxRequestsInHalfOpen), maxRequests,
-		"safeMaxRequests should return default value for excessive input")
-
-	// Check the warning was logged
-	suite.True(suite.logContains("Invalid MaxRequestsInHalfOpen value"),
-		"Warning about invalid MaxRequestsInHalfOpen should be logged")
-
-	// Verify log contains the expected values
-	suite.True(suite.logContains(fmt.Sprintf(`"requested_value":%d`, excessiveValue)),
-		"Requested value not found in warning log")
-	suite.True(suite.logContains(fmt.Sprintf(`"default_value":%d`, defaultMaxRequestsInHalfOpen)),
-		"Default value not found in warning log")
-}
-
-// Start the test suite
-func TestSafeUint32Suite(t *testing.T) {
-	suite.Run(t, new(SafeUint32TestSuite))
-}

server.go

@@ -10,7 +10,6 @@ import (
 	"github.com/gofiber/fiber/v2/middleware/cors"
 	"github.com/google/uuid"
 
-	graphql "github.com/lukaszraczylo/go-simple-graphql"
 	libpack_cache "github.com/lukaszraczylo/graphql-monitoring-proxy/cache"
 	libpack_config "github.com/lukaszraczylo/graphql-monitoring-proxy/config"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
@@ -21,22 +20,8 @@ const (
 	healthCheckQueryStr = `{ __typename }`
 )
 
-// HealthCheckResponse represents the response structure for health check endpoints
-type HealthCheckResponse struct {
-	Status       string                      `json:"status"`       // overall status: "healthy" or "unhealthy"
-	Dependencies map[string]DependencyStatus `json:"dependencies"` // status of each dependency
-	Timestamp    string                      `json:"timestamp"`    // when the health check was performed
-}
-
-// DependencyStatus represents the status of a dependency
-type DependencyStatus struct {
-	Error        *string `json:"error,omitempty"`
-	Status       string  `json:"status"`
-	ResponseTime int64   `json:"responseTime"`
-}
-
 // StartHTTPProxy initializes and starts the HTTP proxy server.
-func StartHTTPProxy() error {
+func StartHTTPProxy() {
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
 		Message: "Starting the HTTP proxy",
 	})
@@ -61,41 +46,21 @@ func StartHTTPProxy() error {
 
 	server.Get("/healthz", healthCheck)
 	server.Get("/livez", healthCheck)
-	server.Get("/health", healthCheck)
-
-	// Register admin dashboard routes if enabled
-	if cfg.AdminDashboard.Enable {
-		adminDash := NewAdminDashboard(cfg.Logger)
-		adminDash.RegisterRoutes(server)
-	}
-
-	// WebSocket support - must be registered before catch-all routes
-	if cfg.WebSocket.Enable {
-		server.Get("/v1/graphql", func(c *fiber.Ctx) error {
-			if IsWebSocketRequest(c) {
-				wsp := GetWebSocketProxy()
-				if wsp != nil {
-					return wsp.HandleWebSocket(c)
-				}
-			}
-			return proxyTheRequestToDefault(c)
-		})
-	}
 
 	server.Post("/*", processGraphQLRequest)
 	server.Get("/*", proxyTheRequestToDefault)
 
 	cfg.Logger.Info(&libpack_logger.LogMessage{
-		Message: "GraphQL proxy starting",
+		Message: "GraphQL proxy started",
 		Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL},
 	})
 
 	if err := server.Listen(fmt.Sprintf(":%d", cfg.Server.PortGraphQL)); err != nil {
-		return fmt.Errorf("failed to start HTTP proxy server on port %d: %w",
-			cfg.Server.PortGraphQL, err)
+		cfg.Logger.Critical(&libpack_logger.LogMessage{
+			Message: "Can't start the service",
+			Pairs:   map[string]interface{}{"port": cfg.Server.PortGraphQL, "error": err.Error()},
+		})
 	}
-
-	return nil
 }
 
 // proxyTheRequestToDefault proxies the request to the default GraphQL endpoint.
@@ -119,221 +84,76 @@ func checkAllowedURLs(c *fiber.Ctx) bool {
 	return ok
 }
 
-// healthCheck performs a comprehensive health check on the GraphQL server and its dependencies.
+// healthCheck performs a health check on the GraphQL server.
 func healthCheck(c *fiber.Ctx) error {
-	// Prepare the response structure
-	response := HealthCheckResponse{
-		Status:       "healthy",
-		Dependencies: make(map[string]DependencyStatus),
-		Timestamp:    time.Now().UTC().Format(time.RFC3339),
-	}
-
-	// Configure checks from query parameters
-	checkGraphQL := true
-	checkRedis := cfg.Cache.CacheRedisEnable
-
-	// Parse query parameters to enable/disable specific checks
-	if c.Query("check_graphql") == "false" {
-		checkGraphQL = false
-	}
-	if c.Query("check_redis") == "false" {
-		checkRedis = false
-	}
-
-	// Check GraphQL backend service
-	if checkGraphQL {
-		startTime := time.Now()
-		graphqlStatus := DependencyStatus{
-			Status: "up",
-		}
-
-		// Try to connect to main GraphQL endpoint
-		endpoint := cfg.Server.HostGraphQL
-		if len(cfg.Server.HealthcheckGraphQL) > 0 {
-			endpoint = cfg.Server.HealthcheckGraphQL
-		}
-
-		// Create a new GraphQL client for the health check
-		tempClient := graphql.NewConnection()
-		tempClient.SetEndpoint(endpoint)
-		_, err := tempClient.Query(healthCheckQueryStr, nil, nil)
-
-		graphqlStatus.ResponseTime = time.Since(startTime).Milliseconds()
+	if len(cfg.Server.HealthcheckGraphQL) > 0 {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Health check enabled",
+			Pairs:   map[string]interface{}{"url": cfg.Server.HealthcheckGraphQL},
+		})
 
+		_, err := cfg.Client.GQLClient.Query(healthCheckQueryStr, nil, nil)
 		if err != nil {
-			errorMsg := err.Error()
-			graphqlStatus.Status = "down"
-			graphqlStatus.Error = &errorMsg
-			response.Status = "unhealthy"
-
 			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Health check: Can't reach the GraphQL server",
-				Pairs: map[string]interface{}{
-					"endpoint":         endpoint,
-					"error":            errorMsg,
-					"response_time_ms": graphqlStatus.ResponseTime,
-				},
+				Message: "Can't reach the GraphQL server",
+				Pairs:   map[string]interface{}{"error": err.Error()},
 			})
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+			return c.Status(fiber.StatusInternalServerError).SendString("Can't reach the GraphQL server with {__typename} query")
 		}
-
-		response.Dependencies["graphql"] = graphqlStatus
-	}
-
-	// Check Redis connectivity if enabled
-	if checkRedis && cfg.Cache.CacheRedisEnable {
-		startTime := time.Now()
-		redisStatus := DependencyStatus{
-			Status: "up",
-		}
-
-		// Implement proper Redis connectivity test
-		redisAccessible := false
-		var redisError error
-
-		if libpack_cache.IsCacheInitialized() {
-			// Try a simple Redis operation to test connectivity
-			testKey := "health_check_test"
-			testValue := []byte("test")
-
-			// Try to set and get a test value
-			libpack_cache.CacheStore(testKey, testValue)
-			retrievedValue := libpack_cache.CacheLookup(testKey)
-
-			if retrievedValue != nil && string(retrievedValue) == "test" {
-				redisAccessible = true
-				// Clean up test key
-				libpack_cache.CacheDelete(testKey)
-			} else {
-				redisError = fmt.Errorf("redis test operation failed")
-			}
-		} else {
-			redisError = fmt.Errorf("cache not initialized")
-		}
-
-		redisStatus.ResponseTime = time.Since(startTime).Milliseconds()
-
-		if !redisAccessible {
-			errorMsg := "Failed to connect to Redis"
-			if redisError != nil {
-				errorMsg = redisError.Error()
-			}
-			redisStatus.Status = "down"
-			redisStatus.Error = &errorMsg
-			response.Status = "unhealthy"
-
-			cfg.Logger.Error(&libpack_logger.LogMessage{
-				Message: "Health check: Can't connect to Redis",
-				Pairs: map[string]interface{}{
-					"server":           cfg.Cache.CacheRedisURL,
-					"error":            errorMsg,
-					"response_time_ms": redisStatus.ResponseTime,
-				},
-			})
-		}
-
-		response.Dependencies["redis"] = redisStatus
-	}
-
-	// Determine appropriate HTTP status code
-	httpStatus := fiber.StatusOK
-	if response.Status == "unhealthy" {
-		httpStatus = fiber.StatusServiceUnavailable
 	}
 
 	cfg.Logger.Debug(&libpack_logger.LogMessage{
-		Message: "Health check completed",
-		Pairs: map[string]interface{}{
-			"status":       response.Status,
-			"dependencies": response.Dependencies,
-		},
+		Message: "Health check returning OK",
 	})
-
-	// Return JSON response
-	return c.Status(httpStatus).JSON(response)
+	return c.Status(fiber.StatusOK).SendString("Health check OK")
 }
 
 // processGraphQLRequest handles the incoming GraphQL requests.
 func processGraphQLRequest(c *fiber.Ctx) error {
 	startTime := time.Now()
 
-	// Extract user information and check permissions
-	extractedUserID, extractedRoleName := extractUserInfo(c)
+	extractedUserID := "-"
+	extractedRoleName := "-"
+
+	if authorization := c.Get("Authorization"); authorization != "" && (len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
+		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(authorization)
+	}
 
-	// Check if user is banned
 	if checkIfUserIsBanned(c, extractedUserID) {
 		return c.Status(fiber.StatusForbidden).SendString("User is banned")
 	}
 
-	// Apply rate limiting if enabled
-	if cfg.Client.RoleRateLimit && !rateLimitedRequest(extractedUserID, extractedRoleName) {
-		return c.Status(fiber.StatusTooManyRequests).SendString("Rate limit exceeded, try again later")
-	}
-
-	// Parse the GraphQL query
-	parsedResult := parseGraphQLQuery(c)
-
-	// Debug logging for mutation routing analysis (enabled when LOG_LEVEL=DEBUG)
-	if cfg.LogLevel == "DEBUG" {
-		var m map[string]interface{}
-		if err := json.Unmarshal(c.Body(), &m); err == nil {
-			if query, ok := m["query"].(string); ok {
-				debugParseGraphQLQuery(c, query)
-			}
-		}
-	}
-
-	if parsedResult.shouldBlock {
-		return c.Status(fiber.StatusForbidden).SendString("Request blocked")
-	}
-
-	// Handle non-GraphQL requests
-	if parsedResult.shouldIgnore {
-		return proxyTheRequest(c, parsedResult.activeEndpoint)
-	}
-
-	// Handle caching
-	wasCached, err := handleCaching(c, parsedResult, extractedUserID)
-	if err != nil {
-		return err
-	}
-
-	// Log and monitor the request
-	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, time.Since(startTime), startTime)
-
-	return nil
-}
-
-// extractUserInfo extracts user ID and role from request headers
-func extractUserInfo(c *fiber.Ctx) (string, string) {
-	extractedUserID := "-"
-	extractedRoleName := "-"
-
-	// Extract from JWT if available
-	if authorization := c.Get("Authorization"); authorization != "" &&
-		(len(cfg.Client.JWTUserClaimPath) > 0 || len(cfg.Client.JWTRoleClaimPath) > 0) {
-		extractedUserID, extractedRoleName = extractClaimsFromJWTHeader(authorization)
-	}
-
-	// Override role from header if configured
 	if cfg.Client.RoleFromHeader != "" {
 		if role := c.Get(cfg.Client.RoleFromHeader); role != "" {
 			extractedRoleName = role
 		}
 	}
 
-	return extractedUserID, extractedRoleName
-}
+	if cfg.Client.RoleRateLimit {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Rate limiting enabled",
+			Pairs:   map[string]interface{}{"user_id": extractedUserID, "role_name": extractedRoleName},
+		})
+		if !rateLimitedRequest(extractedUserID, extractedRoleName) {
+			return c.Status(fiber.StatusTooManyRequests).SendString("Rate limit exceeded, try again later")
+		}
+	}
 
-// handleCaching manages the caching logic for GraphQL requests
-func handleCaching(c *fiber.Ctx, parsedResult *parseGraphQLQueryResult, userID string) (bool, error) {
-	// Extract user role for cache key (in addition to userID already passed)
-	_, userRole := extractUserInfo(c)
+	parsedResult := parseGraphQLQuery(c) // Ensure this function is defined elsewhere
+	if parsedResult.shouldBlock {
+		return c.Status(fiber.StatusForbidden).SendString("Request blocked")
+	}
 
-	// Calculate query hash for cache key - now includes user context for security
-	calculatedQueryHash := libpack_cache.CalculateHash(c, userID, userRole)
+	if parsedResult.shouldIgnore {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Request passed as-is - probably not a GraphQL",
+		})
+		return proxyTheRequest(c, parsedResult.activeEndpoint)
+	}
+
+	calculatedQueryHash := libpack_cache.CalculateHash(c)
 
-	// Set cache time from header or default
 	if parsedResult.cacheTime == 0 {
 		if cacheQuery := c.Get("X-Cache-Graphql-Query"); cacheQuery != "" {
 			parsedResult.cacheTime, _ = strconv.Atoi(cacheQuery)
@@ -342,37 +162,56 @@ func handleCaching(c *fiber.Ctx, parsedResult *parseGraphQLQueryResult, userID s
 		}
 	}
 
-	// Handle cache refresh directive
+	wasCached := false //nolint:ineffassign
+
 	if parsedResult.cacheRefresh {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache refresh requested via query",
+			Pairs:   map[string]interface{}{"user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+		})
 		libpack_cache.CacheDelete(calculatedQueryHash)
 	}
 
-	// Check if caching is enabled
-	cacheEnabled := parsedResult.cacheRequest || cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable
-	if !cacheEnabled {
-		// No caching, just proxy the request
-		if err := proxyTheRequest(c, parsedResult.activeEndpoint); err != nil {
-			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-			return false, c.Status(fiber.StatusInternalServerError).SendString("Can't proxy the request - try again later")
+	if parsedResult.cacheRequest || cfg.Cache.CacheEnable || cfg.Cache.CacheRedisEnable {
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache enabled",
+			Pairs:   map[string]interface{}{"via_query": parsedResult.cacheRequest, "via_env": cfg.Cache.CacheEnable},
+		})
+
+		if cachedResponse := libpack_cache.CacheLookup(calculatedQueryHash); cachedResponse != nil {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheHit, nil)
+			cfg.Logger.Debug(&libpack_logger.LogMessage{
+				Message: "Cache hit",
+				Pairs:   map[string]interface{}{"hash": calculatedQueryHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+			})
+			c.Set("X-Cache-Hit", "true")
+			wasCached = true
+			c.Set("Content-Type", "application/json")
+			return c.Send(cachedResponse)
+		}
+
+		cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
+		cfg.Logger.Debug(&libpack_logger.LogMessage{
+			Message: "Cache miss",
+			Pairs:   map[string]interface{}{"hash": calculatedQueryHash, "user_id": extractedUserID, "request_uuid": c.Locals("request_uuid")},
+		})
+		if err := proxyAndCacheTheRequest(c, calculatedQueryHash, parsedResult.cacheTime, parsedResult.activeEndpoint); err != nil {
+			return err
+		}
+	} else {
+		if err := proxyTheRequest(c, parsedResult.activeEndpoint); err != nil {
+			cfg.Logger.Error(&libpack_logger.LogMessage{
+				Message: "Can't proxy the request",
+				Pairs:   map[string]interface{}{"error": err.Error()},
+			})
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+			return c.Status(fiber.StatusInternalServerError).SendString("Can't proxy the request - try again later")
 		}
-		return false, nil
 	}
 
-	// Try to get from cache
-	if cachedResponse := libpack_cache.CacheLookup(calculatedQueryHash); cachedResponse != nil {
-		cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheHit, nil)
-		c.Set("X-Cache-Hit", "true")
-		c.Set("Content-Type", "application/json")
-		return true, c.Send(cachedResponse)
-	}
+	logAndMonitorRequest(c, extractedUserID, parsedResult.operationType, parsedResult.operationName, wasCached, time.Since(startTime), startTime)
 
-	// Cache miss, proxy and cache
-	cfg.Monitoring.Increment(libpack_monitoring.MetricsCacheMiss, nil)
-	if err := proxyAndCacheTheRequest(c, calculatedQueryHash, parsedResult.cacheTime, parsedResult.activeEndpoint); err != nil {
-		return false, err
-	}
-
-	return false, nil
+	return nil
 }
 
 // proxyAndCacheTheRequest proxies and caches the request if needed.

shutdown.go

@@ -1,194 +0,0 @@
-package main
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-)
-
-// ShutdownManager manages graceful shutdown for all components
-type ShutdownManager struct {
-	ctx          context.Context
-	cancel       context.CancelFunc
-	components   []ShutdownComponent
-	wg           sync.WaitGroup
-	shutdownOnce sync.Once
-	mu           sync.Mutex
-}
-
-// ShutdownComponent represents a component that needs graceful shutdown
-type ShutdownComponent struct {
-	Shutdown func(context.Context) error
-	Name     string
-}
-
-// NewShutdownManager creates a new shutdown manager
-func NewShutdownManager(ctx context.Context) *ShutdownManager {
-	ctx, cancel := context.WithCancel(ctx)
-	return &ShutdownManager{
-		ctx:    ctx,
-		cancel: cancel,
-	}
-}
-
-// RegisterComponent registers a component for graceful shutdown
-func (sm *ShutdownManager) RegisterComponent(name string, shutdown func(context.Context) error) {
-	sm.mu.Lock()
-	defer sm.mu.Unlock()
-	sm.components = append(sm.components, ShutdownComponent{
-		Name:     name,
-		Shutdown: shutdown,
-	})
-}
-
-// RunGoroutine starts a goroutine that respects the shutdown context
-func (sm *ShutdownManager) RunGoroutine(name string, fn func(context.Context)) {
-	sm.wg.Add(1)
-	go func() {
-		defer sm.wg.Done()
-		cfgMutex.RLock()
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-		if logger != nil {
-			logger.Debug(&libpack_logging.LogMessage{
-				Message: "Starting managed goroutine",
-				Pairs:   map[string]interface{}{"name": name},
-			})
-		}
-		fn(sm.ctx)
-		cfgMutex.RLock()
-		logger = cfg.Logger
-		cfgMutex.RUnlock()
-		if logger != nil {
-			logger.Debug(&libpack_logging.LogMessage{
-				Message: "Managed goroutine finished",
-				Pairs:   map[string]interface{}{"name": name},
-			})
-		}
-	}()
-}
-
-// Shutdown initiates graceful shutdown of all components
-func (sm *ShutdownManager) Shutdown(timeout time.Duration) error {
-	var err error
-	sm.shutdownOnce.Do(func() {
-		err = sm.doShutdown(timeout)
-	})
-	return err
-}
-
-// doShutdown performs the actual shutdown logic
-func (sm *ShutdownManager) doShutdown(timeout time.Duration) error {
-	cfgMutex.RLock()
-	logger := cfg.Logger
-	cfgMutex.RUnlock()
-	if logger != nil {
-		logger.Info(&libpack_logging.LogMessage{
-			Message: "Initiating graceful shutdown",
-		})
-	}
-
-	// Cancel the context to signal all goroutines to stop
-	sm.cancel()
-
-	// Create a timeout context for component shutdown
-	shutdownCtx, shutdownCancel := context.WithTimeout(context.Background(), timeout)
-	defer shutdownCancel()
-
-	// Shutdown all registered components
-	sm.mu.Lock()
-	components := make([]ShutdownComponent, len(sm.components))
-	copy(components, sm.components)
-	sm.mu.Unlock()
-
-	var shutdownWg sync.WaitGroup
-	for _, comp := range components {
-		shutdownWg.Add(1)
-		go func(c ShutdownComponent) {
-			defer shutdownWg.Done()
-			cfgMutex.RLock()
-			logger := cfg.Logger
-			cfgMutex.RUnlock()
-			if logger != nil {
-				logger.Info(&libpack_logging.LogMessage{
-					Message: "Shutting down component",
-					Pairs:   map[string]interface{}{"component": c.Name},
-				})
-			}
-			if err := c.Shutdown(shutdownCtx); err != nil {
-				cfgMutex.RLock()
-				logger := cfg.Logger
-				cfgMutex.RUnlock()
-				if logger != nil {
-					logger.Error(&libpack_logging.LogMessage{
-						Message: "Error shutting down component",
-						Pairs: map[string]interface{}{
-							"component": c.Name,
-							"error":     err.Error(),
-						},
-					})
-				}
-			}
-		}(comp)
-	}
-
-	// Wait for all components to shutdown
-	componentsDone := make(chan struct{})
-	go func() {
-		shutdownWg.Wait()
-		close(componentsDone)
-	}()
-
-	// Wait for goroutines with timeout
-	goroutinesDone := make(chan struct{})
-	go func() {
-		sm.wg.Wait()
-		close(goroutinesDone)
-	}()
-
-	select {
-	case <-componentsDone:
-		cfgMutex.RLock()
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-		if logger != nil {
-			logger.Info(&libpack_logging.LogMessage{
-				Message: "All components shut down successfully",
-			})
-		}
-	case <-shutdownCtx.Done():
-		cfgMutex.RLock()
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-		if logger != nil {
-			logger.Warning(&libpack_logging.LogMessage{
-				Message: "Component shutdown timed out",
-			})
-		}
-	}
-
-	select {
-	case <-goroutinesDone:
-		cfgMutex.RLock()
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-		if logger != nil {
-			logger.Info(&libpack_logging.LogMessage{
-				Message: "All goroutines finished",
-			})
-		}
-	case <-time.After(timeout):
-		cfgMutex.RLock()
-		logger := cfg.Logger
-		cfgMutex.RUnlock()
-		if logger != nil {
-			logger.Warning(&libpack_logging.LogMessage{
-				Message: "Some goroutines didn't finish within timeout",
-			})
-		}
-	}
-
-	return nil
-}

shutdown_test.go

@@ -1,325 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-
-	libpack_logging "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/suite"
-)
-
-type ShutdownTestSuite struct {
-	suite.Suite
-	origCfg *config
-}
-
-func TestShutdownTestSuite(t *testing.T) {
-	suite.Run(t, new(ShutdownTestSuite))
-}
-
-func (suite *ShutdownTestSuite) SetupTest() {
-	cfgMutex.RLock()
-	suite.origCfg = cfg
-	cfgMutex.RUnlock()
-	cfgMutex.Lock()
-	cfg = &config{
-		Logger: libpack_logging.New(),
-	}
-	cfgMutex.Unlock()
-}
-
-func (suite *ShutdownTestSuite) TearDownTest() {
-	cfgMutex.Lock()
-	cfg = suite.origCfg
-	cfgMutex.Unlock()
-}
-
-func (suite *ShutdownTestSuite) TestNewShutdownManager() {
-	ctx := context.Background()
-	sm := NewShutdownManager(ctx)
-
-	assert.NotNil(suite.T(), sm)
-	assert.NotNil(suite.T(), sm.ctx)
-	assert.NotNil(suite.T(), sm.cancel)
-	assert.Empty(suite.T(), sm.components)
-}
-
-func (suite *ShutdownTestSuite) TestRegisterComponent() {
-	sm := NewShutdownManager(context.Background())
-
-	// Register multiple components
-	sm.RegisterComponent("component1", func(ctx context.Context) error {
-		return nil
-	})
-
-	sm.RegisterComponent("component2", func(ctx context.Context) error {
-		return nil
-	})
-
-	assert.Len(suite.T(), sm.components, 2)
-	assert.Equal(suite.T(), "component1", sm.components[0].Name)
-	assert.Equal(suite.T(), "component2", sm.components[1].Name)
-}
-
-func (suite *ShutdownTestSuite) TestRegisterComponentConcurrent() {
-	sm := NewShutdownManager(context.Background())
-
-	var wg sync.WaitGroup
-	numComponents := 100
-
-	for i := 0; i < numComponents; i++ {
-		wg.Add(1)
-		go func(idx int) {
-			defer wg.Done()
-			sm.RegisterComponent(
-				"component"+string(rune(idx)),
-				func(ctx context.Context) error {
-					return nil
-				},
-			)
-		}(i)
-	}
-
-	wg.Wait()
-	assert.Len(suite.T(), sm.components, numComponents)
-}
-
-func (suite *ShutdownTestSuite) TestRunGoroutine() {
-	sm := NewShutdownManager(context.Background())
-
-	goroutineStarted := make(chan bool, 1)
-	goroutineFinished := make(chan bool, 1)
-
-	sm.RunGoroutine("test-goroutine", func(ctx context.Context) {
-		goroutineStarted <- true
-		<-ctx.Done()
-		goroutineFinished <- true
-	})
-
-	// Wait for goroutine to start
-	select {
-	case <-goroutineStarted:
-		// Good, goroutine started
-	case <-time.After(100 * time.Millisecond):
-		suite.T().Fatal("Goroutine did not start")
-	}
-
-	// Cancel context to trigger shutdown
-	sm.cancel()
-
-	// Wait for goroutine to finish
-	select {
-	case <-goroutineFinished:
-		// Good, goroutine finished
-	case <-time.After(100 * time.Millisecond):
-		suite.T().Fatal("Goroutine did not finish")
-	}
-}
-
-func (suite *ShutdownTestSuite) TestRunGoroutineMultiple() {
-	sm := NewShutdownManager(context.Background())
-
-	var counter int32
-	numGoroutines := 10
-
-	for i := 0; i < numGoroutines; i++ {
-		sm.RunGoroutine("goroutine"+string(rune(i)), func(ctx context.Context) {
-			atomic.AddInt32(&counter, 1)
-			<-ctx.Done()
-			atomic.AddInt32(&counter, -1)
-		})
-	}
-
-	// Give goroutines time to start
-	time.Sleep(50 * time.Millisecond)
-	assert.Equal(suite.T(), int32(numGoroutines), atomic.LoadInt32(&counter))
-
-	// Cancel and wait for shutdown
-	sm.cancel()
-	sm.wg.Wait()
-
-	assert.Equal(suite.T(), int32(0), atomic.LoadInt32(&counter))
-}
-
-func (suite *ShutdownTestSuite) TestShutdownSuccess() {
-	sm := NewShutdownManager(context.Background())
-
-	component1Shutdown := false
-	sm.RegisterComponent("component1", func(ctx context.Context) error {
-		component1Shutdown = true
-		return nil
-	})
-
-	component2Shutdown := false
-	sm.RegisterComponent("component2", func(ctx context.Context) error {
-		component2Shutdown = true
-		return nil
-	})
-
-	goroutineShutdown := make(chan bool, 1)
-	sm.RunGoroutine("test-goroutine", func(ctx context.Context) {
-		<-ctx.Done()
-		goroutineShutdown <- true
-	})
-
-	// Perform shutdown
-	err := sm.Shutdown(1 * time.Second)
-	assert.NoError(suite.T(), err)
-
-	// Verify all components were shut down
-	assert.True(suite.T(), component1Shutdown)
-	assert.True(suite.T(), component2Shutdown)
-
-	// Verify goroutine was shut down
-	select {
-	case <-goroutineShutdown:
-		// Good
-	case <-time.After(100 * time.Millisecond):
-		suite.T().Fatal("Goroutine did not shut down")
-	}
-}
-
-func (suite *ShutdownTestSuite) TestShutdownWithError() {
-	sm := NewShutdownManager(context.Background())
-
-	componentShutdown := false
-	sm.RegisterComponent("failing-component", func(ctx context.Context) error {
-		componentShutdown = true
-		return errors.New("shutdown failed")
-	})
-
-	// Shutdown should continue even if a component fails
-	err := sm.Shutdown(1 * time.Second)
-	assert.NoError(suite.T(), err) // Shutdown manager doesn't return component errors
-	assert.True(suite.T(), componentShutdown)
-}
-
-func (suite *ShutdownTestSuite) TestShutdownTimeout() {
-	sm := NewShutdownManager(context.Background())
-
-	// Register a component that takes too long to shutdown
-	sm.RegisterComponent("slow-component", func(ctx context.Context) error {
-		select {
-		case <-time.After(2 * time.Second):
-			return nil
-		case <-ctx.Done():
-			return ctx.Err()
-		}
-	})
-
-	// Shutdown with short timeout
-	start := time.Now()
-	err := sm.Shutdown(100 * time.Millisecond)
-	elapsed := time.Since(start)
-
-	// Should timeout quickly
-	assert.NoError(suite.T(), err)
-	assert.Less(suite.T(), elapsed, 500*time.Millisecond)
-}
-
-func (suite *ShutdownTestSuite) TestShutdownConcurrentComponents() {
-	sm := NewShutdownManager(context.Background())
-
-	var shutdownOrder []int
-	var mu sync.Mutex
-
-	// Register multiple components that shutdown concurrently
-	for i := 0; i < 5; i++ {
-		idx := i
-		sm.RegisterComponent("component"+string(rune(idx)), func(ctx context.Context) error {
-			time.Sleep(time.Duration(idx*10) * time.Millisecond)
-			mu.Lock()
-			shutdownOrder = append(shutdownOrder, idx)
-			mu.Unlock()
-			return nil
-		})
-	}
-
-	err := sm.Shutdown(1 * time.Second)
-	assert.NoError(suite.T(), err)
-
-	// All components should have shut down
-	assert.Len(suite.T(), shutdownOrder, 5)
-}
-
-func (suite *ShutdownTestSuite) TestShutdownIdempotent() {
-	sm := NewShutdownManager(context.Background())
-
-	shutdownCount := int32(0)
-	sm.RegisterComponent("component", func(ctx context.Context) error {
-		atomic.AddInt32(&shutdownCount, 1)
-		return nil
-	})
-
-	// First shutdown
-	err := sm.Shutdown(100 * time.Millisecond)
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), int32(1), atomic.LoadInt32(&shutdownCount))
-
-	// Second shutdown should be safe but not call components again
-	err = sm.Shutdown(100 * time.Millisecond)
-	assert.NoError(suite.T(), err)
-	assert.Equal(suite.T(), int32(1), atomic.LoadInt32(&shutdownCount))
-}
-
-func (suite *ShutdownTestSuite) TestShutdownEmptyManager() {
-	sm := NewShutdownManager(context.Background())
-
-	// Shutdown with no components should be safe
-	err := sm.Shutdown(100 * time.Millisecond)
-	assert.NoError(suite.T(), err)
-}
-
-func (suite *ShutdownTestSuite) TestContextCancellation() {
-	ctx, cancel := context.WithCancel(context.Background())
-	sm := NewShutdownManager(ctx)
-
-	goroutineExited := make(chan bool, 1)
-	sm.RunGoroutine("test-goroutine", func(ctx context.Context) {
-		<-ctx.Done()
-		goroutineExited <- true
-	})
-
-	// Cancel the parent context
-	cancel()
-
-	// Goroutine should still exit properly
-	select {
-	case <-goroutineExited:
-		// Good
-	case <-time.After(100 * time.Millisecond):
-		suite.T().Fatal("Goroutine did not exit after context cancellation")
-	}
-}
-
-// Benchmark tests
-func BenchmarkRegisterComponent(b *testing.B) {
-	sm := NewShutdownManager(context.Background())
-	b.ResetTimer()
-
-	for i := 0; i < b.N; i++ {
-		sm.RegisterComponent("component", func(ctx context.Context) error {
-			return nil
-		})
-	}
-}
-
-func BenchmarkShutdown(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		b.StopTimer()
-		sm := NewShutdownManager(context.Background())
-		for j := 0; j < 10; j++ {
-			sm.RegisterComponent("component"+string(rune(j)), func(ctx context.Context) error {
-				return nil
-			})
-		}
-		b.StartTimer()
-
-		sm.Shutdown(100 * time.Millisecond)
-	}
-}

static/app/default-ratelimit.json

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

static/kubernetes-deployment.yaml

@@ -58,7 +58,7 @@ spec:
           - name: MONITORING_PORT
             value: "9393"
           - name: HOST_GRAPHQL
-            value: http://hasura-internal:8080/
+            value: http://hasura-internal:8080/v1/graphql
           - name: ENABLE_GLOBAL_CACHE
             value: "true"
           - name: CACHE_TTL