feat: prometheus remote (#848)

moira-alert · Aug 29, 2023 · 6bb22d4 · 6bb22d4
1 parent 4e9751c
commit 6bb22d4
Show file tree

Hide file tree

Showing 77 changed files with 2,408 additions and 706 deletions.
diff --git a/api/config.go b/api/config.go
@@ -4,10 +4,11 @@ import "time"
 
 // Config for api configuration variables.
 type Config struct {
-	EnableCORS      bool
-	Listen          string
-	LocalMetricTTL  time.Duration
-	RemoteMetricTTL time.Duration
+	EnableCORS                bool
+	Listen                    string
+	GraphiteLocalMetricTTL    time.Duration
+	GraphiteRemoteMetricTTL   time.Duration
+	PrometheusRemoteMetricTTL time.Duration
 }
 
 // WebConfig is container for web ui configuration parameters.

diff --git a/api/controller/trigger.go b/api/controller/trigger.go
@@ -55,7 +55,7 @@ func saveTrigger(dataBase moira.Database, trigger *moira.Trigger, triggerID stri
 		lastCheck.UpdateScore()
 	}
 
-	if err = dataBase.SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote); err != nil {
+	if err = dataBase.SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource); err != nil {
 		return nil, api.ErrorInternalServer(err)
 	}
 

diff --git a/api/controller/trigger_metrics.go b/api/controller/trigger_metrics.go
@@ -113,7 +113,7 @@ func deleteTriggerMetrics(dataBase moira.Database, metricName string, triggerID
 	if err = dataBase.RemovePatternsMetrics(trigger.Patterns); err != nil {
 		return api.ErrorInternalServer(err)
 	}
-	if err = dataBase.SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote); err != nil {
+	if err = dataBase.SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource); err != nil {
 		return api.ErrorInternalServer(err)
 	}
 	return nil

diff --git a/api/controller/trigger_metrics_test.go b/api/controller/trigger_metrics_test.go
@@ -40,7 +40,7 @@ func TestDeleteTriggerMetric(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.IsRemote)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.TriggerSource)
 		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
 		So(err, ShouldBeNil)
 		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
@@ -53,7 +53,7 @@ func TestDeleteTriggerMetric(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.IsRemote)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.TriggerSource)
 		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
 		So(err, ShouldBeNil)
 		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
@@ -117,7 +117,7 @@ func TestDeleteTriggerMetric(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(lastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote).Return(expected)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource).Return(expected)
 		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
 		So(err, ShouldResemble, api.ErrorInternalServer(expected))
 	})
@@ -175,7 +175,7 @@ func TestDeleteTriggerNodataMetrics(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.IsRemote)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.TriggerSource)
 		err := DeleteTriggerNodataMetrics(dataBase, triggerID)
 		So(err, ShouldBeNil)
 		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
@@ -188,7 +188,7 @@ func TestDeleteTriggerNodataMetrics(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.IsRemote)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.TriggerSource)
 		err := DeleteTriggerNodataMetrics(dataBase, triggerID)
 		So(err, ShouldBeNil)
 		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
@@ -201,7 +201,7 @@ func TestDeleteTriggerNodataMetrics(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheckWithoutNodata, trigger.IsRemote)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheckWithoutNodata, trigger.TriggerSource)
 		err := DeleteTriggerNodataMetrics(dataBase, triggerID)
 		So(err, ShouldBeNil)
 		So(expectedLastCheck, ShouldResemble, lastCheckWithoutNodata)
@@ -214,7 +214,7 @@ func TestDeleteTriggerNodataMetrics(t *testing.T) {
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
 		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.IsRemote)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &expectedLastCheck, trigger.TriggerSource)
 		err := DeleteTriggerNodataMetrics(dataBase, triggerID)
 		So(err, ShouldBeNil)
 		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
@@ -269,7 +269,7 @@ func TestGetTriggerMetrics(t *testing.T) {
 	localSource := mock_metric_source.NewMockMetricSource(mockCtrl)
 	remoteSource := mock_metric_source.NewMockMetricSource(mockCtrl)
 	fetchResult := mock_metric_source.NewMockFetchResult(mockCtrl)
-	sourceProvider := metricSource.CreateMetricSourceProvider(localSource, remoteSource)
+	sourceProvider := metricSource.CreateMetricSourceProvider(localSource, remoteSource, nil)
 	pattern := "super.puper.pattern"
 	metric := "super.puper.metric"
 
@@ -278,23 +278,35 @@ func TestGetTriggerMetrics(t *testing.T) {
 	var retention int64 = 10
 
 	Convey("Trigger is remote but remote is not configured", t, func() {
-		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{ID: triggerID, Targets: []string{pattern}, IsRemote: true}, nil)
+		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{
+			ID:            triggerID,
+			Targets:       []string{pattern},
+			TriggerSource: moira.GraphiteRemote,
+		}, nil)
 		remoteSource.EXPECT().IsConfigured().Return(false, nil)
 		triggerMetrics, err := GetTriggerMetrics(dataBase, sourceProvider, from, until, triggerID)
 		So(err, ShouldResemble, api.ErrorInternalServer(metricSource.ErrMetricSourceIsNotConfigured))
 		So(triggerMetrics, ShouldBeNil)
 	})
 
 	Convey("Trigger is remote but remote has bad config", t, func() {
-		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{ID: triggerID, Targets: []string{pattern}, IsRemote: true}, nil)
+		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{
+			ID:            triggerID,
+			Targets:       []string{pattern},
+			TriggerSource: moira.GraphiteRemote,
+		}, nil)
 		remoteSource.EXPECT().IsConfigured().Return(false, remote.ErrRemoteStorageDisabled)
 		triggerMetrics, err := GetTriggerMetrics(dataBase, sourceProvider, from, until, triggerID)
 		So(err, ShouldResemble, api.ErrorInternalServer(remote.ErrRemoteStorageDisabled))
 		So(triggerMetrics, ShouldBeNil)
 	})
 
 	Convey("Has metrics", t, func() {
-		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{ID: triggerID, Targets: []string{pattern}}, nil)
+		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{
+			ID:            triggerID,
+			Targets:       []string{pattern},
+			TriggerSource: moira.GraphiteLocal,
+		}, nil)
 		localSource.EXPECT().IsConfigured().Return(true, nil)
 		localSource.EXPECT().Fetch(pattern, from, until, false).Return(fetchResult, nil)
 		fetchResult.EXPECT().GetMetricsData().Return([]metricSource.MetricData{*metricSource.MakeMetricData(metric, []float64{0, 1, 2, 3, 4}, retention, from)})
@@ -319,11 +331,20 @@ func TestGetTriggerMetrics(t *testing.T) {
 	})
 
 	Convey("Fetch error", t, func() {
-		expectedError := remote.ErrRemoteTriggerResponse{InternalError: fmt.Errorf("some error"), Target: pattern}
-		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{ID: triggerID, Targets: []string{pattern}, IsRemote: true}, nil)
+		expectedError := remote.ErrRemoteTriggerResponse{
+			InternalError: fmt.Errorf("some error"),
+			Target:        pattern,
+		}
+		dataBase.EXPECT().GetTrigger(triggerID).Return(moira.Trigger{
+			ID:            triggerID,
+			Targets:       []string{pattern},
+			TriggerSource: moira.GraphiteRemote,
+		}, nil)
 		remoteSource.EXPECT().IsConfigured().Return(true, nil)
 		remoteSource.EXPECT().Fetch(pattern, from, until, false).Return(nil, expectedError)
+
 		triggerMetrics, err := GetTriggerMetrics(dataBase, sourceProvider, from, until, triggerID)
+
 		So(err, ShouldResemble, api.ErrorInternalServer(expectedError))
 		So(triggerMetrics, ShouldBeNil)
 	})

diff --git a/api/controller/trigger_test.go b/api/controller/trigger_test.go
@@ -27,7 +27,7 @@ func TestUpdateTrigger(t *testing.T) {
 		dataBase.EXPECT().AcquireTriggerCheckLock(gomock.Any(), 10)
 		dataBase.EXPECT().DeleteTriggerCheckLock(gomock.Any())
 		dataBase.EXPECT().GetTriggerLastCheck(gomock.Any()).Return(moira.CheckData{}, database.ErrNil)
-		dataBase.EXPECT().SetTriggerLastCheck(gomock.Any(), gomock.Any(), trigger.IsRemote).Return(nil)
+		dataBase.EXPECT().SetTriggerLastCheck(gomock.Any(), gomock.Any(), trigger.TriggerSource).Return(nil)
 		dataBase.EXPECT().SaveTrigger(gomock.Any(), trigger).Return(nil)
 		resp, err := UpdateTrigger(dataBase, &triggerModel, triggerModel.ID, make(map[string]bool))
 		So(err, ShouldBeNil)
@@ -77,7 +77,7 @@ func TestSaveTrigger(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)
@@ -88,7 +88,7 @@ func TestSaveTrigger(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(actualLastCheck, nil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &emptyLastCheck, trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &emptyLastCheck, trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)
@@ -101,7 +101,7 @@ func TestSaveTrigger(t *testing.T) {
 		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-		dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.IsRemote).Return(nil)
+		dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.TriggerSource).Return(nil)
 		dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 		resp, err := saveTrigger(dataBase, &trigger, triggerID, map[string]bool{"super.metric1": true, "super.metric2": true})
 		So(err, ShouldBeNil)
@@ -133,7 +133,7 @@ func TestSaveTrigger(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.IsRemote).Return(expected)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.TriggerSource).Return(expected)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldResemble, api.ErrorInternalServer(expected))
 			So(resp, ShouldBeNil)
@@ -144,7 +144,7 @@ func TestSaveTrigger(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any(), trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(expected)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldResemble, api.ErrorInternalServer(expected))
@@ -175,7 +175,7 @@ func TestVariousTtlState(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)
@@ -190,7 +190,7 @@ func TestVariousTtlState(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)
@@ -205,7 +205,7 @@ func TestVariousTtlState(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)
@@ -220,7 +220,7 @@ func TestVariousTtlState(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)
@@ -235,7 +235,7 @@ func TestVariousTtlState(t *testing.T) {
 			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID, 10)
 			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
 			dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(moira.CheckData{}, database.ErrNil)
-			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.IsRemote).Return(nil)
+			dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck, trigger.TriggerSource).Return(nil)
 			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
 			resp, err := saveTrigger(dataBase, &trigger, triggerID, make(map[string]bool))
 			So(err, ShouldBeNil)

diff --git a/api/dto/target.go b/api/dto/target.go
@@ -6,6 +6,7 @@ import (
 
 	"github.com/go-graphite/carbonapi/expr/functions"
 	"github.com/go-graphite/carbonapi/expr/metadata"
+	"github.com/moira-alert/moira"
 
 	"github.com/go-graphite/carbonapi/pkg/parser"
 )
@@ -128,7 +129,19 @@ type TreeOfProblems struct {
 }
 
 // TargetVerification validates trigger targets.
-func TargetVerification(targets []string, ttl time.Duration, isRemote bool) []TreeOfProblems {
+func TargetVerification(targets []string, ttl time.Duration, triggerSource moira.TriggerSource) ([]TreeOfProblems, error) {
+	switch triggerSource {
+	case moira.PrometheusRemote:
+		return []TreeOfProblems{{SyntaxOk: true}}, nil
+
+	case moira.GraphiteLocal, moira.GraphiteRemote:
+		return graphiteTargetVerification(targets, ttl, triggerSource), nil
+	}
+
+	return nil, fmt.Errorf("unknown trigger source '%s'", triggerSource)
+}
+
+func graphiteTargetVerification(targets []string, ttl time.Duration, triggerSource moira.TriggerSource) []TreeOfProblems {
 	functionsOfTargets := make([]TreeOfProblems, 0)
 
 	for _, target := range targets {
@@ -147,7 +160,7 @@ func TargetVerification(targets []string, ttl time.Duration, isRemote bool) []Tr
 			continue
 		}
 
-		functionsOfTarget.TreeOfProblems = checkExpression(expr, ttl, isRemote)
+		functionsOfTarget.TreeOfProblems = checkExpression(expr, ttl, triggerSource)
 		functionsOfTargets = append(functionsOfTargets, functionsOfTarget)
 	}
 
@@ -167,13 +180,13 @@ func DoesAnyTreeHaveError(trees []TreeOfProblems) bool {
 }
 
 // checkExpression validates expression.
-func checkExpression(expression parser.Expr, ttl time.Duration, isRemote bool) *ProblemOfTarget {
+func checkExpression(expression parser.Expr, ttl time.Duration, triggerSource moira.TriggerSource) *ProblemOfTarget {
 	if !expression.IsFunc() {
 		return nil
 	}
 
 	funcName := expression.Target()
-	problemFunction := checkFunction(funcName, isRemote)
+	problemFunction := checkFunction(funcName, triggerSource)
 
 	if argument, ok := functionArgumentsInTheRangeTTL(expression, ttl); !ok {
 		if problemFunction == nil {
@@ -195,7 +208,7 @@ func checkExpression(expression parser.Expr, ttl time.Duration, isRemote bool) *
 			continue
 		}
 
-		if badFunc := checkExpression(argument, ttl, isRemote); badFunc != nil {
+		if badFunc := checkExpression(argument, ttl, triggerSource); badFunc != nil {
 			badFunc.Position = position
 
 			if problemFunction == nil {
@@ -209,7 +222,11 @@ func checkExpression(expression parser.Expr, ttl time.Duration, isRemote bool) *
 	return problemFunction
 }
 
-func checkFunction(funcName string, isRemote bool) *ProblemOfTarget {
+func checkFunction(funcName string, triggerSource moira.TriggerSource) *ProblemOfTarget {
+	if triggerSource != moira.GraphiteLocal {
+		return nil
+	}
+
 	if _, isUnstable := unstableFunctions[funcName]; isUnstable {
 		return &ProblemOfTarget{
 			Argument:    funcName,
@@ -234,7 +251,7 @@ func checkFunction(funcName string, isRemote bool) *ProblemOfTarget {
 		}
 	}
 
-	if !isRemote && !funcIsSupported(funcName) {
+	if !funcIsSupported(funcName) {
 		return &ProblemOfTarget{
 			Argument:    funcName,
 			Type:        isBad,