Vendored API conflicts

Signed-off-by: Ganesh Vernekar <[email protected]>

Author: codesome

pkg/alertmanager/alertmanager.go

@@ -45,7 +45,7 @@ type Alertmanager struct {
 	cfg        *Config
 	api        *api.API
 	logger     log.Logger
-	nflog      nflog.Log
+	nflog      *nflog.Log
 	silences   *silence.Silences
 	marker     types.Marker
 	alerts     *mem.Alerts
@@ -115,7 +115,7 @@ func New(cfg *Config) (*Alertmanager, error) {
 		return nil, fmt.Errorf("failed to create alerts: %v", err)
 	}
 
-	am.api = api.New(
+	am.api, err = api.New(
 		am.alerts,
 		am.silences,
 		func(matchers []*labels.Matcher) dispatch.AlertOverview {
@@ -125,6 +125,9 @@ func New(cfg *Config) (*Alertmanager, error) {
 		nil, // Passing a nil mesh router since we don't show mesh router information in Cortex anyway.
 		log.With(am.logger, "component", "api"),
 	)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create api: %v", err)
+	}
 
 	am.router = route.New()
 

pkg/chunk/aws/metrics_autoscaling.go

@@ -363,10 +363,19 @@ func promQuery(ctx context.Context, promAPI promV1.API, query string, duration,
 		Step:  step,
 	}
 
-	value, err := promAPI.QueryRange(ctx, query, queryRange)
+	value, wrngs, err := promAPI.QueryRange(ctx, query, queryRange)
 	if err != nil {
 		return nil, err
 	}
+	if wrngs != nil {
+		level.Warn(util.Logger).Log(
+			"query", query,
+			"start", queryRange.Start,
+			"end", queryRange.End,
+			"step", queryRange.Step,
+			"warnings", wrngs,
+		)
+	}
 	matrix, ok := value.(model.Matrix)
 	if !ok {
 		return nil, fmt.Errorf("Unable to convert value to matrix: %#v", value)

pkg/chunk/aws/metrics_autoscaling_test.go

@@ -7,6 +7,7 @@ import (
 	"time"
 
 	"github.com/pkg/errors"
+	"github.com/prometheus/client_golang/api"
 	promV1 "github.com/prometheus/client_golang/api/prometheus/v1"
 	"github.com/prometheus/common/model"
 
@@ -428,28 +429,32 @@ func (m *mockPrometheus) SetResponseForReads(usageRates [][]int, errorRates [][]
 	}
 }
 
-func (m *mockPrometheus) Query(ctx context.Context, query string, ts time.Time) (model.Value, error) {
-	return nil, errors.New("not implemented")
+func (m *mockPrometheus) Query(ctx context.Context, query string, ts time.Time) (model.Value, api.Warnings, error) {
+	return nil, nil, errors.New("not implemented")
 }
 
-func (m *mockPrometheus) QueryRange(ctx context.Context, query string, r promV1.Range) (model.Value, error) {
+func (m *mockPrometheus) QueryRange(ctx context.Context, query string, r promV1.Range) (model.Value, api.Warnings, error) {
 	if len(m.rangeValues) == 0 {
-		return nil, errors.New("mockPrometheus.QueryRange: out of values")
+		return nil, nil, errors.New("mockPrometheus.QueryRange: out of values")
 	}
 	// Take the first value and move the slice up
 	ret := m.rangeValues[0]
 	m.rangeValues = m.rangeValues[1:]
-	return ret, nil
+	return ret, nil, nil
 }
 
 func (m *mockPrometheus) LabelValues(ctx context.Context, label string) (model.LabelValues, error) {
 	return nil, errors.New("not implemented")
 }
 
-func (m *mockPrometheus) Series(ctx context.Context, matches []string, startTime time.Time, endTime time.Time) ([]model.LabelSet, error) {
+func (m *mockPrometheus) LabelNames(ctx context.Context) ([]string, error) {
 	return nil, errors.New("not implemented")
 }
 
+func (m *mockPrometheus) Series(ctx context.Context, matches []string, startTime time.Time, endTime time.Time) ([]model.LabelSet, api.Warnings, error) {
+	return nil, nil, errors.New("not implemented")
+}
+
 func (m *mockPrometheus) AlertManagers(ctx context.Context) (promV1.AlertManagersResult, error) {
 	return promV1.AlertManagersResult{}, errors.New("not implemented")
 }
@@ -481,3 +486,11 @@ func (m *mockPrometheus) Rules(ctx context.Context) (promV1.RulesResult, error)
 func (m *mockPrometheus) Targets(ctx context.Context) (promV1.TargetsResult, error) {
 	return promV1.TargetsResult{}, errors.New("not implemented")
 }
+
+func (m *mockPrometheus) Alerts(ctx context.Context) (promV1.AlertsResult, error) {
+	return promV1.AlertsResult{}, errors.New("not implemented")
+}
+
+func (m *mockPrometheus) TargetsMetadata(ctx context.Context, matchTarget string, metric string, limit string) ([]promV1.MetricMetadata, error) {
+	return nil, errors.New("not implemented")
+}

pkg/configs/configs.go

@@ -214,6 +214,7 @@ func (c RulesConfig) parseV2() (map[string][]rules.Rule, error) {
 						time.Duration(rl.For),
 						labels.FromMap(rl.Labels),
 						labels.FromMap(rl.Annotations),
+						nil,
 						true,
 						log.With(util.Logger, "alert", rl.Alert),
 					))
@@ -262,7 +263,7 @@ func (c RulesConfig) parseV1() (map[string][]rules.Rule, error) {
 				}
 
 				rule = rules.NewAlertingRule(
-					r.Name, expr, r.Duration, r.Labels, r.Annotations, true,
+					r.Name, expr, r.Duration, r.Labels, r.Annotations, nil, true,
 					log.With(util.Logger, "alert", r.Name),
 				)
 

pkg/configs/configs_test.go

@@ -46,6 +46,7 @@ func TestParseLegacyAlerts(t *testing.T) {
 		labels.Labels{
 			labels.Label{Name: "message", Value: "I am a message"},
 		},
+		nil,
 		true,
 		log.With(util.Logger, "alert", "TestAlert"),
 	)

pkg/configs/legacy_promql/engine_test.go

@@ -132,9 +132,11 @@ type errQuerier struct {
 func (q *errQuerier) Select(*storage.SelectParams, ...*labels.Matcher) (storage.SeriesSet, storage.Warnings, error) {
 	return errSeriesSet{err: q.err}, nil, q.err
 }
-func (*errQuerier) LabelValues(name string) ([]string, error) { return nil, nil }
-func (*errQuerier) LabelNames() ([]string, error)             { return nil, nil }
-func (*errQuerier) Close() error                              { return nil }
+func (q *errQuerier) LabelValues(name string) ([]string, storage.Warnings, error) {
+	return nil, nil, q.err
+}
+func (q *errQuerier) LabelNames() ([]string, storage.Warnings, error) { return nil, nil, q.err }
+func (q *errQuerier) Close() error                                    { return q.err }
 
 // errSeriesSet implements storage.SeriesSet which always returns error.
 type errSeriesSet struct {