NETOBSERV-1706: fix error displayed due to max-chunk-age (#552)

When Loki is disabled, do not try to fetch max-chunk-age.
More changes alongside:

- fetch max-chunk-age as part of the config fetching (ie. just 1 API
  call instead of 2)
  -> this simplifies a bit the loading sequence on the frontend
- Use mapstructure for decoding loki config (refactor getting limits &
  max-chunk-age in that way)
- Manage unset max-chunk-age more explicitly (undefined instead of NaN)
- Add tests

Author: jotak

go.mod

@@ -7,6 +7,7 @@ toolchain go1.21.7
 require (
 	github.com/gorilla/mux v1.8.1
 	github.com/json-iterator/go v1.1.12
+	github.com/mitchellh/mapstructure v1.5.0
 	github.com/prometheus/client_golang v1.19.0
 	github.com/prometheus/common v0.52.3
 	github.com/sirupsen/logrus v1.9.3

go.sum

@@ -54,6 +54,8 @@ github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
 github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0=
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
 github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
 github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=

pkg/config/config.go

@@ -127,6 +127,7 @@ type Frontend struct {
 	Fields          []FieldConfig `yaml:"fields" json:"fields"`
 	DataSources     []string      `yaml:"dataSources" json:"dataSources"`
 	PromLabels      []string      `yaml:"promLabels" json:"promLabels"`
+	MaxChunkAgeMs   int           `yaml:"maxChunkAgeMs,omitempty" json:"maxChunkAgeMs,omitempty"` // populated at query time
 }
 
 type Config struct {

pkg/handler/frontend-config.go

@@ -11,16 +11,23 @@ func (h *Handlers) GetFrontendConfig() func(w http.ResponseWriter, r *http.Reque
 	if err != nil {
 		hlog.Errorf("Could not read config file: %v", err)
 	}
-	return func(w http.ResponseWriter, _ *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
 		if err != nil {
 			cfg, err = config.ReadFile(h.Cfg.Frontend.BuildVersion, h.Cfg.Frontend.BuildDate, h.Cfg.Path)
 			if err != nil {
 				writeError(w, http.StatusInternalServerError, err.Error())
+			}
+		}
+		if h.Cfg.IsLokiEnabled() {
+			// (Re)load Loki max chunk age
+			lokiClient := newLokiClient(&h.Cfg.Loki, r.Header, true)
+			if maxChunkAge, err := h.fetchIngesterMaxChunkAge(lokiClient); err != nil {
+				// Log the error, but keep returning known config
+				hlog.Errorf("Could not get max chunk age: %v", err)
 			} else {
-				writeJSON(w, http.StatusOK, cfg.Frontend)
+				cfg.Frontend.MaxChunkAgeMs = int(maxChunkAge.Milliseconds())
 			}
-		} else {
-			writeJSON(w, http.StatusOK, cfg.Frontend)
 		}
+		writeJSON(w, http.StatusOK, cfg.Frontend)
 	}
 }

pkg/handler/loki.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/mitchellh/mapstructure"
 	"github.com/sirupsen/logrus"
 	"gopkg.in/yaml.v3"
 
@@ -254,65 +255,79 @@ func (h *Handlers) LokiBuildInfos() func(w http.ResponseWriter, r *http.Request)
 	}
 }
 
-func (h *Handlers) LokiConfig(param string) func(w http.ResponseWriter, r *http.Request) {
-	return func(w http.ResponseWriter, r *http.Request) {
-		if !h.Cfg.IsLokiEnabled() {
-			writeError(w, http.StatusBadRequest, "Loki is disabled")
-			return
-		}
-		lokiClient := newLokiClient(&h.Cfg.Loki, r.Header, true)
-		baseURL := strings.TrimRight(h.Cfg.Loki.GetStatusURL(), "/")
+func (h *Handlers) fetchLokiConfig(cl httpclient.Caller, output any) error {
+	baseURL := strings.TrimRight(h.Cfg.Loki.GetStatusURL(), "/")
 
-		resp, code, err := executeLokiQuery(fmt.Sprintf("%s/%s", baseURL, "config"), lokiClient)
-		if err != nil {
-			writeError(w, code, err.Error())
-			return
-		}
+	resp, _, err := executeLokiQuery(fmt.Sprintf("%s/%s", baseURL, "config"), cl)
+	if err != nil {
+		return err
+	}
 
-		cfg := make(map[string]interface{})
-		err = yaml.Unmarshal(resp, &cfg)
-		if err != nil {
-			hlog.WithError(err).Errorf("cannot unmarshal, response was: %v", string(resp))
-			writeError(w, code, err.Error())
-			return
-		}
-		writeJSON(w, code, cfg[param])
+	cfg := make(map[string]interface{})
+	err = yaml.Unmarshal(resp, &cfg)
+	if err != nil {
+		hlog.WithError(err).Errorf("cannot unmarshal Loki config, response was: %v", string(resp))
+		return err
+	}
+
+	err = mapstructure.Decode(cfg, output)
+	if err != nil {
+		hlog.WithError(err).Errorf("cannot decode Loki config, response was: %v", cfg)
+		return err
 	}
+
+	return nil
 }
 
-func (h *Handlers) IngesterMaxChunkAge() func(w http.ResponseWriter, r *http.Request) {
+func (h *Handlers) LokiLimits() func(w http.ResponseWriter, r *http.Request) {
 	return func(w http.ResponseWriter, r *http.Request) {
 		if !h.Cfg.IsLokiEnabled() {
-			writeError(w, http.StatusBadRequest, "Loki is disabled")
+			writeJSON(w, http.StatusNoContent, "Loki is disabled")
 			return
 		}
 		lokiClient := newLokiClient(&h.Cfg.Loki, r.Header, true)
-		baseURL := strings.TrimRight(h.Cfg.Loki.GetStatusURL(), "/")
-
-		resp, code, err := executeLokiQuery(fmt.Sprintf("%s/%s", baseURL, "config"), lokiClient)
+		limits, err := h.fetchLokiLimits(lokiClient)
 		if err != nil {
-			writeError(w, code, err.Error())
+			hlog.WithError(err).Error("cannot fetch Loki limits")
+			writeError(w, http.StatusInternalServerError, err.Error())
 			return
 		}
+		writeJSON(w, http.StatusOK, limits)
+	}
+}
 
-		cfg := make(map[string]interface{})
-		err = yaml.Unmarshal(resp, &cfg)
-		if err != nil {
-			hlog.WithError(err).Errorf("cannot unmarshal, response was: %v", string(resp))
-			writeError(w, code, err.Error())
-			return
-		}
+func (h *Handlers) fetchLokiLimits(cl httpclient.Caller) (map[string]any, error) {
+	type LimitsConfig struct {
+		Limits map[string]any `mapstructure:"limits_config"`
+	}
+	limitsCfg := LimitsConfig{}
+	if err := h.fetchLokiConfig(cl, &limitsCfg); err != nil {
+		return nil, fmt.Errorf("Error when fetching Loki limits: %w", err)
+	}
+	return limitsCfg.Limits, nil
+}
+
+func (h *Handlers) fetchIngesterMaxChunkAge(cl httpclient.Caller) (time.Duration, error) {
+	type ChunkAgeConfig struct {
+		Ingester struct {
+			MaxChunkAge string `mapstructure:"max_chunk_age"`
+		} `mapstructure:"ingester"`
+	}
+	ageCfg := ChunkAgeConfig{}
+	if err := h.fetchLokiConfig(cl, &ageCfg); err != nil {
+		return 0, fmt.Errorf("error when fetching Loki ingester max chunk age: %w", err)
+	}
 
+	if ageCfg.Ingester.MaxChunkAge == "" {
 		// default max chunk age is 2h
 		// see https://grafana.com/docs/loki/latest/configure/#ingester
-		var maxChunkAge interface{} = "2h"
-		if cfg["ingester"] != nil {
-			ingester := cfg["ingester"].(map[string]interface{})
-			if ingester["max_chunk_age"] != nil {
-				maxChunkAge = ingester["max_chunk_age"]
-			}
-		}
+		return 2 * time.Hour, nil
+	}
 
-		writeJSON(w, code, maxChunkAge)
+	parsed, err := time.ParseDuration(ageCfg.Ingester.MaxChunkAge)
+	if err != nil {
+		return 0, fmt.Errorf("cannot parse max chunk age: %w", err)
 	}
+
+	return parsed, nil
 }

pkg/handler/loki_test.go

@@ -0,0 +1,48 @@
+package handler
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/netobserv/network-observability-console-plugin/pkg/httpclient/httpclienttest"
+)
+
+func TestFetchLimits(t *testing.T) {
+	lokiClientMock := new(httpclienttest.HTTPClientMock)
+	lokiClientMock.On("Get", "http://loki/config").Return([]byte(`{"limits_config": {"somelimit": 42}}`), 200, nil)
+	limits, err := h.fetchLokiLimits(lokiClientMock)
+	require.NoError(t, err)
+
+	assert.Equal(t, map[string]any{"somelimit": 42}, limits)
+}
+
+func TestFetchLimits_Absent(t *testing.T) {
+	lokiClientMock := new(httpclienttest.HTTPClientMock)
+	lokiClientMock.On("Get", "http://loki/config").Return([]byte(`{"any": "any"}`), 200, nil)
+	limits, err := h.fetchLokiLimits(lokiClientMock)
+	require.NoError(t, err)
+
+	assert.Nil(t, limits)
+}
+
+func TestFetchMaxChunkAge(t *testing.T) {
+	lokiClientMock := new(httpclienttest.HTTPClientMock)
+	lokiClientMock.On("Get", "http://loki/config").Return([]byte(`{"ingester": {"max_chunk_age": "10h"}}`), 200, nil)
+	mca, err := h.fetchIngesterMaxChunkAge(lokiClientMock)
+	require.NoError(t, err)
+
+	assert.Equal(t, 10*time.Hour, mca)
+}
+
+func TestFetchMaxChunkAge_Absent(t *testing.T) {
+	lokiClientMock := new(httpclienttest.HTTPClientMock)
+	lokiClientMock.On("Get", "http://loki/config").Return([]byte(`{"any": "any"}`), 200, nil)
+	mca, err := h.fetchIngesterMaxChunkAge(lokiClientMock)
+	require.NoError(t, err)
+
+	// Default value
+	assert.Equal(t, 2*time.Hour, mca)
+}

pkg/httpclient/httpclienttest/http_client_mock.go

@@ -14,10 +14,7 @@ func (o *HTTPClientMock) Get(url string) ([]byte, int, error) {
 }
 
 func (o *HTTPClientMock) SpyURL(fn func(url string)) {
-	o.On(
-		"Get",
-		mock.AnythingOfType("string"),
-	).Run(func(args mock.Arguments) {
-		fn(args[0].(string))
-	}).Return([]byte{}, 0, nil)
+	o.On("Get", mock.AnythingOfType("string")).
+		Run(func(args mock.Arguments) { fn(args[0].(string)) }).
+		Return([]byte{}, 0, nil)
 }

pkg/server/routes.go

@@ -41,8 +41,7 @@ func setupRoutes(ctx context.Context, cfg *config.Config, authChecker auth.Check
 	api.HandleFunc("/loki/ready", h.LokiReady())
 	api.HandleFunc("/loki/metrics", forceCheckAdmin(authChecker, h.LokiMetrics()))
 	api.HandleFunc("/loki/buildinfo", forceCheckAdmin(authChecker, h.LokiBuildInfos()))
-	api.HandleFunc("/loki/config/limits", forceCheckAdmin(authChecker, h.LokiConfig("limits_config")))
-	api.HandleFunc("/loki/config/ingester/max_chunk_age", forceCheckAdmin(authChecker, h.IngesterMaxChunkAge()))
+	api.HandleFunc("/loki/config/limits", forceCheckAdmin(authChecker, h.LokiLimits()))
 	api.HandleFunc("/loki/flow/records", h.GetFlows(ctx))
 	api.HandleFunc("/loki/flow/metrics", h.GetTopology(ctx))
 	api.HandleFunc("/loki/export", h.ExportFlows(ctx))