General code optimisations. (#16)

* General code optimisations.

proxy.go

@@ -3,16 +3,25 @@ package main
 import (
 	"crypto/tls"
 	"fmt"
+	"net/url"
 	"time"
 
 	"github.com/avast/retry-go/v4"
-	fiber "github.com/gofiber/fiber/v2"
+	"github.com/gofiber/fiber/v2"
 	"github.com/gofiber/fiber/v2/middleware/proxy"
 	libpack_logger "github.com/lukaszraczylo/graphql-monitoring-proxy/logging"
 	libpack_monitoring "github.com/lukaszraczylo/graphql-monitoring-proxy/monitoring"
 	"github.com/valyala/fasthttp"
 )
 
+var (
+	httpClient *fasthttp.Client
+)
+
+func init() {
+	httpClient = createFasthttpClient(30) // Assuming a default timeout of 30 seconds
+}
+
 func createFasthttpClient(timeout int) *fasthttp.Client {
 	return &fasthttp.Client{
 		Name:                     "graphql_proxy",
@@ -21,14 +30,13 @@ func createFasthttpClient(timeout int) *fasthttp.Client {
 			InsecureSkipVerify: true,
 		},
 		MaxConnsPerHost:               2048,
-		ReadTimeout:                   time.Second * time.Duration(timeout),
-		WriteTimeout:                  time.Second * time.Duration(timeout),
-		MaxIdleConnDuration:           time.Second * time.Duration(timeout),
-		MaxConnDuration:               time.Second * time.Duration(timeout),
+		ReadTimeout:                   time.Duration(timeout) * time.Second,
+		WriteTimeout:                  time.Duration(timeout) * time.Second,
+		MaxIdleConnDuration:           time.Duration(timeout) * time.Second,
+		MaxConnDuration:               time.Duration(timeout) * time.Second,
 		DisableHeaderNamesNormalizing: true,
 	}
 }
-
 func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
 	if !checkAllowedURLs(c) {
 		cfg.Logger.Error(&libpack_logger.LogMessage{
@@ -38,44 +46,22 @@ func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsSkipped, nil)
 		}
-		c.Status(403).SendString("Request blocked - not allowed URL")
-		return nil
+		return fmt.Errorf("request blocked - not allowed URL: %s", c.Path())
+	}
+
+	proxyURL := currentEndpoint + c.Path()
+	_, err := url.Parse(proxyURL)
+	if err != nil {
+		return fmt.Errorf("invalid URL: %v", err)
 	}
-	c.Request().Header.DisableNormalizing()
-	c.Request().Header.Add("X-Real-IP", c.IP())
-	c.Request().Header.Add(fiber.HeaderXForwardedFor, string(c.Request().Header.Peek("X-Forwarded-For")))
-	c.Request().Header.Del(fiber.HeaderAcceptEncoding)
 
-	// added dummy check for the log level because it executes additional functions which could
-	// potentially slow down the execution.
 	if cfg.LogLevel == "debug" {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Proxying the request",
-			Pairs: map[string]interface{}{
-				"path":         c.Path(),
-				"body":         string(c.Request().Body()),
-				"headers":      c.GetReqHeaders(),
-				"request_uuid": c.Locals("request_uuid"),
-			},
-		})
+		logDebugRequest(c)
 	}
 
-	err := retry.Do(
+	err = retry.Do(
 		func() error {
-			errInt := proxy.DoRedirects(c, currentEndpoint+c.Path(), 3, cfg.Client.FastProxyClient)
-			if errInt != nil {
-				cfg.Logger.Error(&libpack_logger.LogMessage{
-					Message: "Can't proxy the request",
-					Pairs: map[string]interface{}{
-						"error": errInt.Error(),
-					},
-				})
-				if ifNotInTest() {
-					cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
-				}
-				return errInt
-			}
-			return nil
+			return proxy.DoRedirects(c, proxyURL, 3, httpClient)
 		},
 		retry.OnRetry(func(n uint, err error) {
 			cfg.Logger.Warning(&libpack_logger.LogMessage{
@@ -86,42 +72,59 @@ func proxyTheRequest(c *fiber.Ctx, currentEndpoint string) error {
 				},
 			})
 		}),
-		retry.Attempts(uint(3)),
+		retry.Attempts(3),
 		retry.DelayType(retry.BackOffDelay),
-		retry.Delay(time.Duration(250*time.Millisecond)),
+		retry.Delay(250*time.Millisecond),
 		retry.LastErrorOnly(true),
 	)
 
 	if err != nil {
 		cfg.Logger.Warning(&libpack_logger.LogMessage{
 			Message: "Can't proxy the request",
-			Pairs: map[string]interface{}{
-				"error": err.Error(),
-			},
+			Pairs:   map[string]interface{}{"error": err.Error()},
 		})
-		return err
+		if ifNotInTest() {
+			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
+		}
+		return fmt.Errorf("failed to proxy request: %v", err)
 	}
 
 	if cfg.LogLevel == "debug" {
-		cfg.Logger.Debug(&libpack_logger.LogMessage{
-			Message: "Received proxied response",
-			Pairs: map[string]interface{}{
-				"path":          c.Path(),
-				"response_body": string(c.Response().Body()),
-				"response_code": c.Response().StatusCode(),
-				"headers":       c.GetRespHeaders(),
-				"request_uuid":  c.Locals("request_uuid"),
-			},
-		})
+		logDebugResponse(c)
 	}
 
 	if c.Response().StatusCode() != 200 {
 		if ifNotInTest() {
 			cfg.Monitoring.Increment(libpack_monitoring.MetricsFailed, nil)
 		}
-		return fmt.Errorf("Received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
+		return fmt.Errorf("received non-200 response from the GraphQL server: %d", c.Response().StatusCode())
 	}
 
 	c.Response().Header.Del(fiber.HeaderServer)
 	return nil
 }
+
+func logDebugRequest(c *fiber.Ctx) {
+	cfg.Logger.Debug(&libpack_logger.LogMessage{
+		Message: "Proxying the request",
+		Pairs: map[string]interface{}{
+			"path":         c.Path(),
+			"body":         string(c.Body()),
+			"headers":      c.GetReqHeaders(),
+			"request_uuid": c.Locals("request_uuid"),
+		},
+	})
+}
+
+func logDebugResponse(c *fiber.Ctx) {
+	cfg.Logger.Debug(&libpack_logger.LogMessage{
+		Message: "Received proxied response",
+		Pairs: map[string]interface{}{
+			"path":          c.Path(),
+			"response_body": string(c.Response().Body()),
+			"response_code": c.Response().StatusCode(),
+			"headers":       c.GetRespHeaders(),
+			"request_uuid":  c.Locals("request_uuid"),
+		},
+	})
+}