gaxy

Production-ready Google Analytics / Google Tag Manager Proxy built with Go.

Bypass ad blockers, maintain data privacy, and own your analytics pipeline with a blazing-fast, enterprise-grade proxy server.

• Intelligent Caching: Reduces upstream calls by 95%+ with configurable TTL
• Connection Pooling: Optimized HTTP client with connection reuse
• Retry Logic: Automatic retries for transient failures
• Sub-millisecond Latency: Highly optimized request handling

• Rate Limiting: Per-IP token bucket rate limiting
• Security Headers: CSP, X-Frame-Options, X-Content-Type-Options
• Input Validation: Comprehensive request/response validation
• Distroless Container: Minimal attack surface with non-root user

• Prometheus Metrics: Request latency, cache performance, error rates
• Structured Logging: JSON logs with correlation IDs
• Health Endpoints: Detailed system health information
• Request Tracing: Full request lifecycle tracking

• Clean Architecture: Separation of concerns with handlers, services, middleware
• Error Handling: Typed errors with context and proper error propagation
• Configuration: Environment-based config with validation
• Graceful Shutdown: Proper cleanup on termination

docker run -d -p 3000:3000 \
    -e ROUTE_PREFIX=/analytics \
    -e GOOGLE_ORIGIN=https://www.google-analytics.com \
    ghcr.io/duyet/gaxy:latest

docker-compose up -d

# Clone repository
git clone https://github.com/duyet/gaxy.git
cd gaxy

# Run with default config
go run *.go

# Or build and run
make build
./bin/gaxy

• Go 1.24 or later
• Docker (optional)
• Make (optional)

# Install dependencies
make deps

# Run tests
make test

# Run with coverage
make test-coverage

# Format code
make fmt

# Run linters
make lint

# Run server
make run

gaxy/
├── pkg/
│   ├── cache/        # Intelligent caching layer
│   ├── config/       # Configuration management
│   ├── errors/       # Custom error types
│   ├── handler/      # HTTP handlers
│   ├── logger/       # Structured logging
│   ├── metrics/      # Prometheus metrics
│   ├── middleware/   # HTTP middleware
│   ├── proxy/        # Proxy service & client
│   └── ratelimit/    # Rate limiting
├── server.go         # Main application
├── Dockerfile        # Production container
├── Makefile          # Build automation
└── docker-compose.yml # Docker Compose config

Gaxy is configured via environment variables. See .env.example for a complete reference.

docker run -d -p 3000:3000 \
    -e ROUTE_PREFIX=/analytics \
    -e CACHE_ENABLED=true \
    -e RATE_LIMIT_ENABLED=true \
    ghcr.io/duyet/gaxy:latest

See docker-compose.yml for a complete example.

docker-compose up -d

helm repo add duyet https://duyet.github.io/charts
helm install gaxy duyet/gaxy \
    --set config.routePrefix=/analytics \
    --set config.cacheEnabled=true

# 1. Install gcloud SDK
# 2. Deploy
gcloud app deploy

Replace Google Analytics/GTM script URLs with your Gaxy instance:

<!-- Google Analytics -->
<script>
window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
ga('create', 'UA-XXXXX-Y', 'auto');
ga('send', 'pageview');
</script>
<script async src='https://your-gaxy-instance.com/analytics.js'></script>
<!-- End Google Analytics -->

If you configured ROUTE_PREFIX=/analytics:

<script async src='https://your-gaxy-instance.com/analytics/analytics.js'></script>

Gaxy provides several endpoints for monitoring and debugging:

curl http://localhost:3000/ping
# Response: pong

curl http://localhost:3000/health
# Response: JSON with system metrics
{
  "status": "healthy",
  "version": "1.0.0",
  "uptime": "2h15m30s",
  "system": {
    "goroutines": 12,
    "memory_alloc": "15 MB",
    "memory_total": "45 MB",
    "memory_sys": "72 MB",
    "gc_runs": 23
  }
}

curl http://localhost:3000/metrics
# Returns Prometheus-formatted metrics:
# - gaxy_requests_total{status="200"} 12450
# - gaxy_request_duration_seconds{quantile="0.95"} 0.023
# - gaxy_cache_hits_total 11230
# - gaxy_cache_misses_total 1220
# - gaxy_upstream_requests_total{status="200"} 1220
# - gaxy_rate_limit_dropped_total 15

With intelligent caching enabled:

• 95%+ cache hit rate for static assets (analytics.js, gtag.js)
• Sub-millisecond response times for cached content
• Reduced upstream load by 20x
• Lower bandwidth costs for high-traffic sites

# Run benchmarks
make bench

# Example results:
# BenchmarkProxyRequest-8     50000    24532 ns/op    4096 B/op    42 allocs/op
# BenchmarkCacheHit-8      5000000      245 ns/op      64 B/op     2 allocs/op

Example Prometheus configuration:

scrape_configs:
  - job_name: 'gaxy'
    static_configs:
      - targets: ['localhost:3000']
    metrics_path: '/metrics'
    scrape_interval: 15s

Example Grafana queries:

# Request rate
rate(gaxy_requests_total[5m])

# P95 latency
gaxy_request_duration_seconds{quantile="0.95"}

# Cache hit rate
rate(gaxy_cache_hits_total[5m]) / (rate(gaxy_cache_hits_total[5m]) + rate(gaxy_cache_misses_total[5m]))

# Error rate
rate(gaxy_requests_total{status=~"5.."}[5m])

Gaxy implements multiple layers of security to protect your infrastructure:

• SSRF Protection: Validates all request URIs to prevent server-side request forgery
• Path Whitelisting: Only allows known Google Analytics/Tag Manager endpoints
• Rate Limiting: Per-IP token bucket to prevent abuse
• Security Headers: X-Frame-Options, CSP, X-Content-Type-Options
• Input Validation: Comprehensive validation at all entry points
• Container Security: Distroless image, non-root user

1. Enable Rate Limiting: Protect against abuse

   RATE_LIMIT_ENABLED=true
   RATE_LIMIT_RPS=100

2. Use HTTPS: Always run behind HTTPS in production

3. Configure CORS: Restrict origins in production

   CORS_ALLOW_ORIGINS=https://yourdomain.com

4. Monitor Metrics: Set up alerts for anomalies

5. Update Regularly: Keep dependencies up to date

   make deps

For detailed security information, see SECURITY.md.

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

MIT License - see LICENSE file for details

Built with:

• Fiber - Fast HTTP framework
• Fasthttp - High-performance HTTP client

Made with ❤️ by Duyet