add parameterizable duration to retrieve data from prometheus

Signed-off-by: Augustin Husson <husson.augustin@gmail.com>

Author: Nexucis

cmd/promql-langserver/promql-langserver.go

@@ -58,7 +58,7 @@ func main() {
 
 		logger = kitlog.NewSyncLogger(logger)
 
-		handler, err := rest.CreateInstHandler(context.Background(), prometheusClient, logger)
+		handler, err := rest.CreateInstHandler(context.Background(), prometheusClient, logger, config.Interval)
 		if err != nil {
 			log.Fatal(err)
 		}

langserver/completion.go

@@ -312,7 +312,7 @@ func (s *server) completeLabel(ctx context.Context, completions *[]protocol.Comp
 	if vs != nil {
 		metricName = vs.Name
 	}
-	allNames, err := s.metadataService.LabelNames(ctx, metricName, time.Now().Add(-100*time.Hour), time.Now())
+	allNames, err := s.metadataService.LabelNames(ctx, metricName, time.Now().Add(time.Duration(-1*s.config.Interval)), time.Now())
 	if err != nil {
 		// nolint: errcheck
 		s.client.LogMessage(s.lifetime, &protocol.LogMessageParams{
@@ -355,7 +355,7 @@ OUTER:
 
 // nolint: funlen
 func (s *server) completeLabelValue(ctx context.Context, completions *[]protocol.CompletionItem, location *cache.Location, labelName string) error {
-	labelValues, err := s.metadataService.LabelValues(ctx, labelName, time.Now().Add(-100*time.Hour), time.Now())
+	labelValues, err := s.metadataService.LabelValues(ctx, labelName, time.Now().Add(time.Duration(-1*s.config.Interval)), time.Now())
 	if err != nil {
 		// nolint: errcheck
 		s.client.LogMessage(s.lifetime, &protocol.LogMessageParams{

langserver/config.go

@@ -20,18 +20,24 @@ import (
 	"net/url"
 	"os"
 	"strconv"
+	"time"
 
 	"github.com/kelseyhightower/envconfig"
 	"github.com/prometheus-community/promql-langserver/internal/vendored/go-tools/lsp/protocol"
+	"github.com/prometheus/common/model"
 	"gopkg.in/yaml.v3"
 )
 
+const defaultInterval = model.Duration(12 * 3600 * time.Second)
+
 // Config contains the configuration for a server.
 type Config struct {
 	RPCTrace      string    `yaml:"rpc_trace"`
 	LogFormat     LogFormat `yaml:"log_format"`
 	PrometheusURL string    `yaml:"prometheus_url"`
 	RESTAPIPort   uint64    `yaml:"rest_api_port"`
+	// Interval is the time in second used to retrieve label and metrics from Prometheus
+	Interval model.Duration `yaml:"interval"`
 }
 
 // LogFormat is the type used for describing the format of logs.
@@ -49,6 +55,7 @@ var mapLogFormat = map[LogFormat]bool{ // nolint: gochecknoglobals
 	TextFormat: true,
 }
 
+// Parameterizable
 // UnmarshalYAML overrides a function used internally by the yaml.v3 lib.
 func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error {
 	tmp := &Config{}
@@ -72,6 +79,7 @@ func (c *Config) unmarshalENV() error {
 		// the envconfig lib is not able to convert an empty string to the value 0
 		// so we have to convert it manually
 		RESTAPIPort string
+		Interval    string
 	}{}
 	if err := envconfig.Process(prefix, conf); err != nil {
 		return err
@@ -83,6 +91,13 @@ func (c *Config) unmarshalENV() error {
 			return parseError
 		}
 	}
+	if len(conf.Interval) > 0 {
+		var parseError error
+		c.Interval, parseError = model.ParseDuration(conf.Interval)
+		if parseError != nil {
+			return parseError
+		}
+	}
 	c.RPCTrace = conf.RPCTrace
 	c.PrometheusURL = conf.PrometheusURL
 	c.LogFormat = LogFormat(conf.LogFormat)
@@ -105,6 +120,9 @@ func (c *Config) Validate() error {
 		// default value
 		c.LogFormat = TextFormat
 	}
+	if c.Interval <= 0 {
+		c.Interval = defaultInterval
+	}
 
 	return nil
 }

langserver/config_test.go

@@ -31,6 +31,7 @@ func TestUnmarshalENV(t *testing.T) {
 			variables: map[string]string{},
 			expected: &Config{
 				LogFormat: TextFormat,
+				Interval:  defaultInterval,
 			},
 		},
 		{
@@ -40,12 +41,14 @@ func TestUnmarshalENV(t *testing.T) {
 				"LANGSERVER_PROMETHEUSURL": "http://localhost:9090",
 				"LANGSERVER_RESTAPIPORT":   "8080",
 				"LANGSERVER_LOGFORMAT":     "json",
+				"LANGSERVER_INTERVAL":      "1w",
 			},
 			expected: &Config{
 				RPCTrace:      "text",
 				PrometheusURL: "http://localhost:9090",
 				RESTAPIPort:   8080,
 				LogFormat:     JSONFormat,
+				Interval:      604800000000000,
 			},
 		},
 	}

langserver/server.go

@@ -29,6 +29,7 @@ import (
 	"sync"
 
 	promClient "github.com/prometheus-community/promql-langserver/prometheus"
+	"github.com/prometheus/common/model"
 
 	"github.com/go-kit/kit/log"
 	"github.com/prometheus-community/promql-langserver/internal/vendored/go-tools/jsonrpc2"
@@ -83,11 +84,18 @@ func (s Server) Run() error {
 // CreateHeadlessServer creates a locked down server instance for the REST API.
 //
 // "locked down" in this case means, that the instance cannot send or receive any JSONRPC communication. Logging messages that the instance tries to send over JSONRPC are redirected to stderr.
-func CreateHeadlessServer(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger) (HeadlessServer, error) {
+func CreateHeadlessServer(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger, interval model.Duration) (HeadlessServer, error) {
+	conf := &Config{
+		PrometheusURL: metadataService.GetURL(),
+		Interval:      interval,
+	}
+	if interval <= 0 {
+		conf.Interval = defaultInterval
+	}
 	s := &server{
 		client:          &headlessClient{logger: logger},
 		headless:        true,
-		config:          &Config{PrometheusURL: metadataService.GetURL()},
+		config:          conf,
 		metadataService: metadataService,
 	}
 

rest/handler.go

@@ -26,6 +26,7 @@ import (
 	"github.com/prometheus-community/promql-langserver/internal/vendored/go-tools/lsp/protocol"
 	"github.com/prometheus-community/promql-langserver/langserver"
 	promClient "github.com/prometheus-community/promql-langserver/prometheus"
+	"github.com/prometheus/common/model"
 
 	"github.com/prometheus/client_golang/prometheus"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
@@ -38,8 +39,10 @@ import (
 // otherwise you need to provide your own implementation of the interface.
 //
 // The provided Logger should be synchronized.
-func CreateHandler(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger) (http.Handler, error) {
-	return createHandler(ctx, metadataService, logger, false)
+//
+// interval is the period of time (in second) used to retrieve data such as label and metrics from metrics.
+func CreateHandler(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger, interval model.Duration) (http.Handler, error) {
+	return createHandler(ctx, metadataService, logger, false, interval)
 }
 
 // CreateInstHandler creates an instrumented http.Handler for the PromQL langserver REST API.
@@ -53,11 +56,14 @@ func CreateHandler(ctx context.Context, metadataService promClient.MetadataServi
 // otherwise you need to provide your own implementation of the interface.
 //
 // The provided Logger should be synchronized.
-func CreateInstHandler(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger) (http.Handler, error) {
-	return createHandler(ctx, metadataService, logger, true)
+//
+// interval is the period of time (in second) used to retrieve data such as label and metrics from metrics.
+func CreateInstHandler(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger, interval model.Duration) (http.Handler, error) {
+	return createHandler(ctx, metadataService, logger, true, interval)
 }
-func createHandler(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger, metricsEnpoint bool) (http.Handler, error) {
-	lgs, err := langserver.CreateHeadlessServer(ctx, metadataService, logger)
+
+func createHandler(ctx context.Context, metadataService promClient.MetadataService, logger log.Logger, metricsEnpoint bool, interval model.Duration) (http.Handler, error) {
+	lgs, err := langserver.CreateHeadlessServer(ctx, metadataService, logger, interval)
 	if err != nil {
 		return nil, err
 	}