Prometheus: Introduce prometheus backend library (#83952)

* Move files to prometheus-library

* refactor core prometheus to use prometheus-library

* modify client transport options

* mock

* have a type

* import aliases

* rename

* call the right method

* remove unrelated test from the library

* update codeowners

* go work sync

* update go.work.sum

* make swagger-clean && make openapi3-gen

* add promlib to makefile

* remove clilogger

* Export the function

* update unit test

* add prometheus_test.go

* fix mock type

* use mapUtil from grafana-plugin-sdk-go

pkg/promlib/middleware/custom_query_params.go

@@ -0,0 +1,57 @@
+package middleware
+
+import (
+	"net/http"
+	"net/url"
+
+	sdkhttpclient "github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
+)
+
+const (
+	customQueryParametersMiddlewareName = "prom-custom-query-parameters"
+	customQueryParametersKey            = "customQueryParameters"
+	grafanaDataKey                      = "grafanaData"
+)
+
+func CustomQueryParameters(logger log.Logger) sdkhttpclient.Middleware {
+	return sdkhttpclient.NamedMiddlewareFunc(customQueryParametersMiddlewareName, func(opts sdkhttpclient.Options, next http.RoundTripper) http.RoundTripper {
+		grafanaData, exists := opts.CustomOptions[grafanaDataKey]
+		if !exists {
+			return next
+		}
+
+		data, ok := grafanaData.(map[string]any)
+		if !ok {
+			return next
+		}
+		customQueryParamsVal, exists := data[customQueryParametersKey]
+		if !exists {
+			return next
+		}
+
+		customQueryParams, ok := customQueryParamsVal.(string)
+		if !ok || customQueryParams == "" {
+			return next
+		}
+
+		values, err := url.ParseQuery(customQueryParams)
+		if err != nil {
+			logger.Error("Failed to parse custom query parameters, skipping middleware", "error", err)
+			return next
+		}
+
+		return sdkhttpclient.RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+			q := req.URL.Query()
+			for k, keyValues := range values {
+				for _, value := range keyValues {
+					q.Add(k, value)
+				}
+			}
+			req.URL.RawQuery = q.Encode()
+
+			return next.RoundTrip(req)
+		})
+	})
+}

pkg/promlib/middleware/custom_query_params_test.go

@@ -0,0 +1,170 @@
+package middleware
+
+import (
+	"net/http"
+	"net/url"
+	"strings"
+	"testing"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCustomQueryParametersMiddleware(t *testing.T) {
+	require.Equal(t, "customQueryParameters", customQueryParametersKey)
+
+	finalRoundTripper := httpclient.RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+		return &http.Response{StatusCode: http.StatusOK}, nil
+	})
+
+	t.Run("Without custom query parameters set should not apply middleware", func(t *testing.T) {
+		mw := CustomQueryParameters(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, customQueryParametersMiddlewareName, middlewareName.MiddlewareName())
+
+		req, err := http.NewRequest(http.MethodGet, "http://test.com/query?hello=name", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+
+		require.Equal(t, "http://test.com/query?hello=name", req.URL.String())
+	})
+
+	t.Run("Without custom query parameters set as string should not apply middleware", func(t *testing.T) {
+		mw := CustomQueryParameters(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{
+			CustomOptions: map[string]any{
+				customQueryParametersKey: 64,
+			},
+		}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, customQueryParametersMiddlewareName, middlewareName.MiddlewareName())
+
+		req, err := http.NewRequest(http.MethodGet, "http://test.com/query?hello=name", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+
+		require.Equal(t, "http://test.com/query?hello=name", req.URL.String())
+	})
+
+	t.Run("With custom query parameters set as empty string should not apply middleware", func(t *testing.T) {
+		mw := CustomQueryParameters(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{
+			CustomOptions: map[string]any{
+				customQueryParametersKey: "",
+			},
+		}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, customQueryParametersMiddlewareName, middlewareName.MiddlewareName())
+
+		req, err := http.NewRequest(http.MethodGet, "http://test.com/query?hello=name", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+
+		require.Equal(t, "http://test.com/query?hello=name", req.URL.String())
+	})
+
+	t.Run("With custom query parameters set as invalid query string should not apply middleware", func(t *testing.T) {
+		mw := CustomQueryParameters(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{
+			CustomOptions: map[string]any{
+				customQueryParametersKey: "custom=%%abc&test=abc",
+			},
+		}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, customQueryParametersMiddlewareName, middlewareName.MiddlewareName())
+
+		req, err := http.NewRequest(http.MethodGet, "http://test.com/query?hello=name", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+
+		require.Equal(t, "http://test.com/query?hello=name", req.URL.String())
+	})
+
+	t.Run("With custom query parameters set should apply middleware for request URL containing query parameters ", func(t *testing.T) {
+		mw := CustomQueryParameters(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{
+			CustomOptions: map[string]any{
+				grafanaDataKey: map[string]any{
+					customQueryParametersKey: "custom=par/am&second=f oo",
+				},
+			},
+		}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, customQueryParametersMiddlewareName, middlewareName.MiddlewareName())
+
+		req, err := http.NewRequest(http.MethodGet, "http://test.com/query?hello=name", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+
+		require.True(t, strings.HasPrefix(req.URL.String(), "http://test.com/query?"))
+
+		q := req.URL.Query()
+		require.Len(t, q, 3)
+		require.Equal(t, "name", url.QueryEscape(q.Get("hello")))
+		require.Equal(t, "par%2Fam", url.QueryEscape(q.Get("custom")))
+		require.Equal(t, "f+oo", url.QueryEscape(q.Get("second")))
+	})
+
+	t.Run("With custom query parameters set should apply middleware for request URL not containing query parameters", func(t *testing.T) {
+		mw := CustomQueryParameters(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{
+			CustomOptions: map[string]any{
+				grafanaDataKey: map[string]any{
+					customQueryParametersKey: "custom=par/am&second=f oo",
+				},
+			},
+		}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, customQueryParametersMiddlewareName, middlewareName.MiddlewareName())
+
+		req, err := http.NewRequest(http.MethodGet, "http://test.com/query", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+
+		require.Equal(t, "http://test.com/query?custom=par%2Fam&second=f+oo", req.URL.String())
+	})
+}

pkg/promlib/middleware/force_http_get.go

@@ -0,0 +1,30 @@
+package middleware
+
+import (
+	"net/http"
+
+	sdkhttpclient "github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
+)
+
+func ForceHttpGet(logger log.Logger) sdkhttpclient.Middleware {
+	return sdkhttpclient.NamedMiddlewareFunc("force-http-get", func(opts sdkhttpclient.Options, next http.RoundTripper) http.RoundTripper {
+		// the prometheus library we use does not allow us to set the http method.
+		// it's behavior is to first try POST, and if it fails in certain ways
+		// (for example, by returning a method-not-allowed error), it will try GET.
+		// so here, we check if the http-method is POST, and if it is, we
+		// return an artificial method-not-allowed response.
+		// this will cause the prometheus library to retry with GET.
+		return sdkhttpclient.RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+			if req.Method == http.MethodPost {
+				resp := &http.Response{
+					StatusCode: http.StatusMethodNotAllowed,
+				}
+				return resp, nil
+			}
+
+			return next.RoundTrip(req)
+		})
+	})
+}

pkg/promlib/middleware/force_http_get_test.go

@@ -0,0 +1,44 @@
+package middleware
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/httpclient"
+	"github.com/stretchr/testify/require"
+)
+
+func TestEnsureHttpMethodMiddleware(t *testing.T) {
+	t.Run("Name should be correct", func(t *testing.T) {
+		finalRoundTripper := httpclient.RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+			return &http.Response{StatusCode: http.StatusOK}, nil
+		})
+		mw := ForceHttpGet(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{}, finalRoundTripper)
+		require.NotNil(t, rt)
+		middlewareName, ok := mw.(httpclient.MiddlewareName)
+		require.True(t, ok)
+		require.Equal(t, "force-http-get", middlewareName.MiddlewareName())
+	})
+
+	t.Run("Should force GET method", func(t *testing.T) {
+		finalRoundTripper := httpclient.RoundTripperFunc(func(req *http.Request) (*http.Response, error) {
+			return &http.Response{StatusCode: http.StatusOK}, nil
+		})
+
+		mw := ForceHttpGet(backend.NewLoggerWith("logger", "test"))
+		rt := mw.CreateMiddleware(httpclient.Options{}, finalRoundTripper)
+		require.NotNil(t, rt)
+
+		req, err := http.NewRequest(http.MethodPost, "http://example.com", nil)
+		require.NoError(t, err)
+		res, err := rt.RoundTrip(req)
+		require.NoError(t, err)
+		require.NotNil(t, res)
+		require.Equal(t, res.StatusCode, http.StatusMethodNotAllowed)
+		if res.Body != nil {
+			require.NoError(t, res.Body.Close())
+		}
+	})
+}