From 0bfe9db668736ab9950f477562fe4fe0edd24649 Mon Sep 17 00:00:00 2001 From: Isabella Siu Date: Mon, 26 Feb 2024 15:59:54 -0500 Subject: [PATCH] CloudWatch: Move SessionCache onto the instance (#83278) --- pkg/tsdb/cloudwatch/annotation_query_test.go | 4 +- pkg/tsdb/cloudwatch/cloudwatch.go | 76 ++++++++++--------- .../cloudwatch/cloudwatch_integration_test.go | 16 ++-- pkg/tsdb/cloudwatch/cloudwatch_test.go | 49 +++++++----- pkg/tsdb/cloudwatch/log_actions_test.go | 52 ++++++------- pkg/tsdb/cloudwatch/log_sync_query_test.go | 46 ++++++----- .../metric_data_input_builder_test.go | 2 +- .../metric_data_query_builder_test.go | 22 +++--- pkg/tsdb/cloudwatch/metric_find_query_test.go | 12 +-- pkg/tsdb/cloudwatch/test_utils.go | 3 +- pkg/tsdb/cloudwatch/time_series_query_test.go | 36 +++++---- 11 files changed, 166 insertions(+), 152 deletions(-) diff --git a/pkg/tsdb/cloudwatch/annotation_query_test.go b/pkg/tsdb/cloudwatch/annotation_query_test.go index 2aeab655b70..6779c82a896 100644 --- a/pkg/tsdb/cloudwatch/annotation_query_test.go +++ b/pkg/tsdb/cloudwatch/annotation_query_test.go @@ -30,7 +30,7 @@ func TestQuery_AnnotationQuery(t *testing.T) { client = fakeCWAnnotationsClient{describeAlarmsForMetricOutput: &cloudwatch.DescribeAlarmsForMetricOutput{}} im := defaultTestInstanceManager() - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -62,7 +62,7 @@ func TestQuery_AnnotationQuery(t *testing.T) { client = fakeCWAnnotationsClient{describeAlarmsOutput: &cloudwatch.DescribeAlarmsOutput{}} im := defaultTestInstanceManager() - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, diff --git a/pkg/tsdb/cloudwatch/cloudwatch.go b/pkg/tsdb/cloudwatch/cloudwatch.go index 2d89697eb4d..ddff020b694 100644 --- a/pkg/tsdb/cloudwatch/cloudwatch.go +++ b/pkg/tsdb/cloudwatch/cloudwatch.go @@ -47,6 +47,7 @@ type DataQueryJson struct { type DataSource struct { Settings models.CloudWatchSettings HTTPClient *http.Client + sessions SessionCache tagValueCache *cache.Cache ProxyOpts *proxy.Options } @@ -66,7 +67,6 @@ func ProvideService(httpClientProvider *httpclient.Provider) *CloudWatchService executor := newExecutor( datasource.NewInstanceManager(NewInstanceSettings(httpClientProvider)), - awsds.NewSessionCache(), logger, ) @@ -83,11 +83,10 @@ type SessionCache interface { GetSession(c awsds.SessionConfig) (*session.Session, error) } -func newExecutor(im instancemgmt.InstanceManager, sessions SessionCache, logger log.Logger) *cloudWatchExecutor { +func newExecutor(im instancemgmt.InstanceManager, logger log.Logger) *cloudWatchExecutor { e := &cloudWatchExecutor{ - im: im, - sessions: sessions, - logger: logger, + im: im, + logger: logger, } e.resourceHandler = httpadapter.New(e.newResourceMux()) @@ -115,6 +114,7 @@ func NewInstanceSettings(httpClientProvider *httpclient.Provider) datasource.Ins Settings: instanceSettings, HTTPClient: httpClient, tagValueCache: cache.New(tagValueCacheExpiration, tagValueCacheExpiration*5), + sessions: awsds.NewSessionCache(), // this is used to build a custom dialer when secure socks proxy is enabled ProxyOpts: opts.ProxyOptions, }, nil @@ -123,9 +123,8 @@ func NewInstanceSettings(httpClientProvider *httpclient.Provider) datasource.Ins // cloudWatchExecutor executes CloudWatch requests type cloudWatchExecutor struct { - im instancemgmt.InstanceManager - sessions SessionCache - logger log.Logger + im instancemgmt.InstanceManager + logger log.Logger resourceHandler backend.CallResourceHandler } @@ -160,7 +159,7 @@ func (e *cloudWatchExecutor) getRequestContext(ctx context.Context, pluginCtx ba return models.RequestContext{}, err } - sess, err := e.newSession(ctx, pluginCtx, r) + sess, err := instance.newSession(r) if err != nil { return models.RequestContext{}, err } @@ -247,12 +246,12 @@ func (e *cloudWatchExecutor) checkHealthMetrics(ctx context.Context, pluginCtx b MetricName: &metric, } - session, err := e.newSession(ctx, pluginCtx, defaultRegion) + instance, err := e.getInstance(ctx, pluginCtx) if err != nil { return err } - instance, err := e.getInstance(ctx, pluginCtx) + session, err := instance.newSession(defaultRegion) if err != nil { return err } @@ -263,7 +262,7 @@ func (e *cloudWatchExecutor) checkHealthMetrics(ctx context.Context, pluginCtx b } func (e *cloudWatchExecutor) checkHealthLogs(ctx context.Context, pluginCtx backend.PluginContext) error { - session, err := e.newSession(ctx, pluginCtx, defaultRegion) + session, err := e.newSessionFromContext(ctx, pluginCtx, defaultRegion) if err != nil { return err } @@ -272,42 +271,36 @@ func (e *cloudWatchExecutor) checkHealthLogs(ctx context.Context, pluginCtx back return err } -func (e *cloudWatchExecutor) newSession(ctx context.Context, pluginCtx backend.PluginContext, region string) (*session.Session, error) { - instance, err := e.getInstance(ctx, pluginCtx) - if err != nil { - return nil, err - } - +func (ds *DataSource) newSession(region string) (*session.Session, error) { if region == defaultRegion { - if len(instance.Settings.Region) == 0 { + if len(ds.Settings.Region) == 0 { return nil, models.ErrMissingRegion } - region = instance.Settings.Region + region = ds.Settings.Region } - - sess, err := e.sessions.GetSession(awsds.SessionConfig{ + sess, err := ds.sessions.GetSession(awsds.SessionConfig{ // https://github.com/grafana/grafana/issues/46365 // HTTPClient: instance.HTTPClient, Settings: awsds.AWSDatasourceSettings{ - Profile: instance.Settings.Profile, + Profile: ds.Settings.Profile, Region: region, - AuthType: instance.Settings.AuthType, - AssumeRoleARN: instance.Settings.AssumeRoleARN, - ExternalID: instance.Settings.ExternalID, - Endpoint: instance.Settings.Endpoint, - DefaultRegion: instance.Settings.Region, - AccessKey: instance.Settings.AccessKey, - SecretKey: instance.Settings.SecretKey, + AuthType: ds.Settings.AuthType, + AssumeRoleARN: ds.Settings.AssumeRoleARN, + ExternalID: ds.Settings.ExternalID, + Endpoint: ds.Settings.Endpoint, + DefaultRegion: ds.Settings.Region, + AccessKey: ds.Settings.AccessKey, + SecretKey: ds.Settings.SecretKey, }, UserAgentName: aws.String("Cloudwatch"), - AuthSettings: &instance.Settings.GrafanaSettings, + AuthSettings: &ds.Settings.GrafanaSettings, }) if err != nil { return nil, err } // work around until https://github.com/grafana/grafana/issues/39089 is implemented - if instance.Settings.GrafanaSettings.SecureSocksDSProxyEnabled && instance.Settings.SecureSocksProxyEnabled { + if ds.Settings.GrafanaSettings.SecureSocksDSProxyEnabled && ds.Settings.SecureSocksProxyEnabled { // only update the transport to try to avoid the issue mentioned here https://github.com/grafana/grafana/issues/46365 // also, 'sess' is cached and reused, so the first time it might have the transport not set, the following uses it will if sess.Config.HTTPClient.Transport == nil { @@ -320,7 +313,7 @@ func (e *cloudWatchExecutor) newSession(ctx context.Context, pluginCtx backend.P } sess.Config.HTTPClient.Transport = defTransport.Clone() } - err = proxy.New(instance.ProxyOpts).ConfigureSecureSocksHTTPProxy(sess.Config.HTTPClient.Transport.(*http.Transport)) + err = proxy.New(ds.ProxyOpts).ConfigureSecureSocksHTTPProxy(sess.Config.HTTPClient.Transport.(*http.Transport)) if err != nil { return nil, fmt.Errorf("error configuring Secure Socks proxy for Transport: %w", err) } @@ -328,6 +321,15 @@ func (e *cloudWatchExecutor) newSession(ctx context.Context, pluginCtx backend.P return sess, nil } +func (e *cloudWatchExecutor) newSessionFromContext(ctx context.Context, pluginCtx backend.PluginContext, region string) (*session.Session, error) { + instance, err := e.getInstance(ctx, pluginCtx) + if err != nil { + return nil, err + } + + return instance.newSession(region) +} + func (e *cloudWatchExecutor) getInstance(ctx context.Context, pluginCtx backend.PluginContext) (*DataSource, error) { i, err := e.im.Get(ctx, pluginCtx) if err != nil { @@ -339,7 +341,7 @@ func (e *cloudWatchExecutor) getInstance(ctx context.Context, pluginCtx backend. } func (e *cloudWatchExecutor) getCWClient(ctx context.Context, pluginCtx backend.PluginContext, region string) (cloudwatchiface.CloudWatchAPI, error) { - sess, err := e.newSession(ctx, pluginCtx, region) + sess, err := e.newSessionFromContext(ctx, pluginCtx, region) if err != nil { return nil, err } @@ -347,7 +349,7 @@ func (e *cloudWatchExecutor) getCWClient(ctx context.Context, pluginCtx backend. } func (e *cloudWatchExecutor) getCWLogsClient(ctx context.Context, pluginCtx backend.PluginContext, region string) (cloudwatchlogsiface.CloudWatchLogsAPI, error) { - sess, err := e.newSession(ctx, pluginCtx, region) + sess, err := e.newSessionFromContext(ctx, pluginCtx, region) if err != nil { return nil, err } @@ -358,7 +360,7 @@ func (e *cloudWatchExecutor) getCWLogsClient(ctx context.Context, pluginCtx back } func (e *cloudWatchExecutor) getEC2Client(ctx context.Context, pluginCtx backend.PluginContext, region string) (models.EC2APIProvider, error) { - sess, err := e.newSession(ctx, pluginCtx, region) + sess, err := e.newSessionFromContext(ctx, pluginCtx, region) if err != nil { return nil, err } @@ -368,7 +370,7 @@ func (e *cloudWatchExecutor) getEC2Client(ctx context.Context, pluginCtx backend func (e *cloudWatchExecutor) getRGTAClient(ctx context.Context, pluginCtx backend.PluginContext, region string) (resourcegroupstaggingapiiface.ResourceGroupsTaggingAPIAPI, error) { - sess, err := e.newSession(ctx, pluginCtx, region) + sess, err := e.newSessionFromContext(ctx, pluginCtx, region) if err != nil { return nil, err } diff --git a/pkg/tsdb/cloudwatch/cloudwatch_integration_test.go b/pkg/tsdb/cloudwatch/cloudwatch_integration_test.go index 20eae1ac11f..e9ce1632e21 100644 --- a/pkg/tsdb/cloudwatch/cloudwatch_integration_test.go +++ b/pkg/tsdb/cloudwatch/cloudwatch_integration_test.go @@ -68,7 +68,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { {MetricName: aws.String("Test_MetricName8"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("Test_DimensionName4"), Value: aws.String("Value1")}}}, {MetricName: aws.String("Test_MetricName9"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("Test_DimensionName1"), Value: aws.String("Value2")}}}, }, MetricsPerPage: 100} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", @@ -104,7 +104,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { {MetricName: aws.String("Test_MetricName8"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("Test_DimensionName4")}}}, {MetricName: aws.String("Test_MetricName9"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("Test_DimensionName1")}}}, }, MetricsPerPage: 2} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", @@ -129,7 +129,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { t.Run("Should handle standard dimension key query and return hard coded keys", func(t *testing.T) { im := defaultTestInstanceManager() api = mocks.FakeMetricsAPI{} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", @@ -154,7 +154,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { t.Run("Should handle custom namespace dimension key query and return hard coded keys", func(t *testing.T) { im := defaultTestInstanceManager() api = mocks.FakeMetricsAPI{} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", @@ -190,7 +190,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { {MetricName: aws.String("Test_MetricName8"), Namespace: aws.String("AWS/EC2"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("Test_DimensionName4")}}}, {MetricName: aws.String("Test_MetricName9"), Namespace: aws.String("AWS/EC2"), Dimensions: []*cloudwatch.Dimension{{Name: aws.String("Test_DimensionName1")}}}, }, MetricsPerPage: 2} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", @@ -227,7 +227,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { }, }, }, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", @@ -249,7 +249,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { t.Run("Should handle region requests and return regions from the api", func(t *testing.T) { im := defaultTestInstanceManager() - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", Path: `/regions`, @@ -275,7 +275,7 @@ func Test_CloudWatch_CallResource_Integration_Test(t *testing.T) { }}, nil }) - executor := newExecutor(imWithoutDefaultRegion, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(imWithoutDefaultRegion, log.NewNullLogger()) req := &backend.CallResourceRequest{ Method: "GET", Path: `/regions`, diff --git a/pkg/tsdb/cloudwatch/cloudwatch_test.go b/pkg/tsdb/cloudwatch/cloudwatch_test.go index a989c7ada4d..c2287c279c5 100644 --- a/pkg/tsdb/cloudwatch/cloudwatch_test.go +++ b/pkg/tsdb/cloudwatch/cloudwatch_test.go @@ -135,7 +135,7 @@ func Test_CheckHealth(t *testing.T) { t.Run("successfully query metrics and logs", func(t *testing.T) { client = fakeCheckHealthClient{} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.CheckHealth(context.Background(), &backend.CheckHealthRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -154,7 +154,7 @@ func Test_CheckHealth(t *testing.T) { return nil, fmt.Errorf("some logs query error") }} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.CheckHealth(context.Background(), &backend.CheckHealthRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -173,7 +173,7 @@ func Test_CheckHealth(t *testing.T) { return fmt.Errorf("some list metrics error") }} - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.CheckHealth(context.Background(), &backend.CheckHealthRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -188,10 +188,16 @@ func Test_CheckHealth(t *testing.T) { t.Run("fail to get clients", func(t *testing.T) { client = fakeCheckHealthClient{} + im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { + return DataSource{ + Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "us-east-1"}}, + sessions: &fakeSessionCache{getSession: func(c awsds.SessionConfig) (*session.Session, error) { + return nil, fmt.Errorf("some sessions error") + }}, + }, nil + }) - executor := newExecutor(im, &fakeSessionCache{getSession: func(c awsds.SessionConfig) (*session.Session, error) { - return nil, fmt.Errorf("some sessions error") - }}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.CheckHealth(context.Background(), &backend.CheckHealthRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -216,22 +222,25 @@ func TestNewSession_passes_authSettings(t *testing.T) { SecureSocksDSProxyEnabled: true, } im := datasource.NewInstanceManager((func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{ - AWSDatasourceSettings: awsds.AWSDatasourceSettings{ - Region: "us-east-1", + return DataSource{ + Settings: models.CloudWatchSettings{ + AWSDatasourceSettings: awsds.AWSDatasourceSettings{ + Region: "us-east-1", + }, + GrafanaSettings: expectedSettings, }, - GrafanaSettings: expectedSettings, - }}, nil - })) - executor := newExecutor(im, &fakeSessionCache{getSession: func(c awsds.SessionConfig) (*session.Session, error) { - assert.NotNil(t, c.AuthSettings) - assert.Equal(t, expectedSettings, *c.AuthSettings) - return &session.Session{ - Config: &aws.Config{}, + sessions: &fakeSessionCache{getSession: func(c awsds.SessionConfig) (*session.Session, error) { + assert.NotNil(t, c.AuthSettings) + assert.Equal(t, expectedSettings, *c.AuthSettings) + return &session.Session{ + Config: &aws.Config{}, + }, nil + }}, }, nil - }}, log.NewNullLogger()) + })) + executor := newExecutor(im, log.NewNullLogger()) - _, err := executor.newSession(context.Background(), + _, err := executor.newSessionFromContext(context.Background(), backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, "us-east-1") require.NoError(t, err) } @@ -275,7 +284,7 @@ func TestQuery_ResourceRequest_DescribeLogGroups_with_CrossAccountQuerying(t *te }, } - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) err := executor.CallResource(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), req, sender) assert.NoError(t, err) diff --git a/pkg/tsdb/cloudwatch/log_actions_test.go b/pkg/tsdb/cloudwatch/log_actions_test.go index 1155c9090fb..f0d784c60f6 100644 --- a/pkg/tsdb/cloudwatch/log_actions_test.go +++ b/pkg/tsdb/cloudwatch/log_actions_test.go @@ -88,10 +88,10 @@ func TestQuery_handleGetLogEvents_passes_nil_start_and_end_times_to_GetLogEvents cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -122,9 +122,9 @@ func TestQuery_GetLogEvents_returns_response_from_GetLogEvents_to_data_frame_fie return cli } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) cli = &mocks.MockLogEvents{} cli.On("GetLogEventsWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatchlogs.GetLogEventsOutput{ @@ -206,10 +206,10 @@ func TestQuery_StartQuery(t *testing.T) { AWSDatasourceSettings: awsds.AWSDatasourceSettings{ Region: "us-east-2", }, - }}, nil + }, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -263,10 +263,10 @@ func TestQuery_StartQuery(t *testing.T) { AWSDatasourceSettings: awsds.AWSDatasourceSettings{ Region: "us-east-2", }, - }}, nil + }, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -321,9 +321,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("successfully parses information from JSON to StartQueryWithContext", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -357,9 +357,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("does not populate StartQueryInput.limit when no limit provided", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -383,9 +383,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("attaches logGroupIdentifiers if the crossAccount feature is enabled", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -419,9 +419,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("attaches logGroupIdentifiers if the crossAccount feature is enabled and strips out trailing *", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -455,9 +455,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("uses LogGroupNames if the cross account feature flag is not enabled, and log group names is present", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, Queries: []backend.DataQuery{ @@ -490,9 +490,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("ignores logGroups if feature flag is disabled even if logGroupNames is not present", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, Queries: []backend.DataQuery{ @@ -524,9 +524,9 @@ func Test_executeStartQuery(t *testing.T) { t.Run("it always uses logGroups when feature flag is enabled and ignores log group names", func(t *testing.T) { cli = fakeCWLogsClient{} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, Queries: []backend.DataQuery{ @@ -589,7 +589,7 @@ func TestQuery_StopQuery(t *testing.T) { } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) timeRange := backend.TimeRange{ @@ -597,7 +597,7 @@ func TestQuery_StopQuery(t *testing.T) { To: time.Unix(1584700643, 0), } - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -684,10 +684,10 @@ func TestQuery_GetQueryResults(t *testing.T) { } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, diff --git a/pkg/tsdb/cloudwatch/log_sync_query_test.go b/pkg/tsdb/cloudwatch/log_sync_query_test.go index 112b4746b6b..f1bed59ccfa 100644 --- a/pkg/tsdb/cloudwatch/log_sync_query_test.go +++ b/pkg/tsdb/cloudwatch/log_sync_query_test.go @@ -37,11 +37,11 @@ func Test_executeSyncLogQuery(t *testing.T) { t.Run("getCWLogsClient is called with region from input JSON", func(t *testing.T) { cli = fakeCWLogsClient{queryResults: cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Complete")}} - im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil - }) sess := fakeSessionCache{} - executor := newExecutor(im, &sess, log.NewNullLogger()) + im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &sess}, nil + }) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, @@ -63,12 +63,12 @@ func Test_executeSyncLogQuery(t *testing.T) { t.Run("getCWLogsClient is called with region from instance manager when region is default", func(t *testing.T) { cli = fakeCWLogsClient{queryResults: cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Complete")}} - im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "instance manager's region"}}}, nil - }) sess := fakeSessionCache{} + im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { + return DataSource{Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "instance manager's region"}}, sessions: &sess}, nil + }) - executor := newExecutor(im, &sess, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -121,11 +121,10 @@ func Test_executeSyncLogQuery(t *testing.T) { syncCalled = false cli = fakeCWLogsClient{queryResults: cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Complete")}} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "instance manager's region"}}}, nil + return DataSource{Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "instance manager's region"}}, sessions: &fakeSessionCache{}}, nil }) - sess := fakeSessionCache{} - executor := newExecutor(im, &sess, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: tc.headers, PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -164,11 +163,10 @@ func Test_executeSyncLogQuery(t *testing.T) { cli = fakeCWLogsClient{queryResults: cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Complete")}} im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "instance manager's region"}}}, nil + return DataSource{Settings: models.CloudWatchSettings{AWSDatasourceSettings: awsds.AWSDatasourceSettings{Region: "instance manager's region"}}, sessions: &fakeSessionCache{}}, nil }) - sess := fakeSessionCache{} - executor := newExecutor(im, &sess, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, Queries: []backend.DataQuery{ @@ -205,9 +203,9 @@ func Test_executeSyncLogQuery_handles_RefId_from_input_queries(t *testing.T) { }, nil) cli.On("GetQueryResultsWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Complete")}, nil) im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) res, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, @@ -234,9 +232,9 @@ func Test_executeSyncLogQuery_handles_RefId_from_input_queries(t *testing.T) { }, nil) cli.On("GetQueryResultsWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Complete")}, nil) im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) res, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, @@ -303,9 +301,9 @@ func Test_executeSyncLogQuery_handles_RefId_from_input_queries(t *testing.T) { Status: aws.String("Complete")}, nil) im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) res, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, @@ -348,10 +346,10 @@ func Test_executeSyncLogQuery_handles_RefId_from_input_queries(t *testing.T) { }, nil) cli.On("GetQueryResultsWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatchlogs.GetQueryResultsOutput{Status: aws.String("Running")}, nil) im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{LogsTimeout: models.Duration{Duration: time.Millisecond}}}, nil + return DataSource{Settings: models.CloudWatchSettings{LogsTimeout: models.Duration{Duration: time.Millisecond}}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, @@ -381,9 +379,9 @@ func Test_executeSyncLogQuery_handles_RefId_from_input_queries(t *testing.T) { &fakeAWSError{code: "foo", message: "bar"}, ) im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) res, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ Headers: map[string]string{headerFromAlert: "some value"}, diff --git a/pkg/tsdb/cloudwatch/metric_data_input_builder_test.go b/pkg/tsdb/cloudwatch/metric_data_input_builder_test.go index eaa35e3931d..e891f996d2b 100644 --- a/pkg/tsdb/cloudwatch/metric_data_input_builder_test.go +++ b/pkg/tsdb/cloudwatch/metric_data_input_builder_test.go @@ -27,7 +27,7 @@ func TestMetricDataInputBuilder(t *testing.T) { for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.TimezoneUTCOffset = tc.timezoneUTCOffset diff --git a/pkg/tsdb/cloudwatch/metric_data_query_builder_test.go b/pkg/tsdb/cloudwatch/metric_data_query_builder_test.go index e033481a308..b956a88a45f 100644 --- a/pkg/tsdb/cloudwatch/metric_data_query_builder_test.go +++ b/pkg/tsdb/cloudwatch/metric_data_query_builder_test.go @@ -13,7 +13,7 @@ import ( func TestMetricDataQueryBuilder(t *testing.T) { t.Run("buildMetricDataQuery", func(t *testing.T) { t.Run("should use metric stat", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeBuilder query.MetricQueryType = models.MetricQueryTypeSearch @@ -25,7 +25,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should pass AccountId in metric stat query", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeBuilder query.MetricQueryType = models.MetricQueryTypeSearch @@ -36,7 +36,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should leave AccountId in metric stat query", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeBuilder query.MetricQueryType = models.MetricQueryTypeSearch @@ -46,7 +46,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should use custom built expression", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeBuilder query.MetricQueryType = models.MetricQueryTypeSearch @@ -58,7 +58,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should use sql expression", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeRaw query.MetricQueryType = models.MetricQueryTypeQuery @@ -70,7 +70,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should use user defined math expression", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeRaw query.MetricQueryType = models.MetricQueryTypeSearch @@ -82,7 +82,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should set period in user defined expression", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.MetricEditorMode = models.MetricEditorModeRaw query.MetricQueryType = models.MetricQueryTypeSearch @@ -96,7 +96,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should set label", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.Label = "some label" @@ -108,7 +108,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should not set label for empty string query label", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := getBaseQuery() query.Label = "" @@ -119,7 +119,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run(`should not specify accountId when it is "all"`, func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := &models.CloudWatchQuery{ Namespace: "AWS/EC2", MetricName: "CPUUtilization", @@ -137,7 +137,7 @@ func TestMetricDataQueryBuilder(t *testing.T) { }) t.Run("should set accountId when it is specified", func(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(nil, log.NewNullLogger()) query := &models.CloudWatchQuery{ Namespace: "AWS/EC2", MetricName: "CPUUtilization", diff --git a/pkg/tsdb/cloudwatch/metric_find_query_test.go b/pkg/tsdb/cloudwatch/metric_find_query_test.go index f8c73ac8f59..400c3041620 100644 --- a/pkg/tsdb/cloudwatch/metric_find_query_test.go +++ b/pkg/tsdb/cloudwatch/metric_find_query_test.go @@ -53,7 +53,7 @@ func TestQuery_InstanceAttributes(t *testing.T) { } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) filterMap := map[string][]string{ @@ -62,7 +62,7 @@ func TestQuery_InstanceAttributes(t *testing.T) { filterJson, err := json.Marshal(filterMap) require.NoError(t, err) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.handleGetEc2InstanceAttribute( context.Background(), backend.PluginContext{ @@ -137,10 +137,10 @@ func TestQuery_EBSVolumeIDs(t *testing.T) { } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.handleGetEbsVolumeIds( context.Background(), backend.PluginContext{ @@ -198,7 +198,7 @@ func TestQuery_ResourceARNs(t *testing.T) { } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) tagMap := map[string][]string{ @@ -207,7 +207,7 @@ func TestQuery_ResourceARNs(t *testing.T) { tagJson, err := json.Marshal(tagMap) require.NoError(t, err) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.handleGetResourceArns( context.Background(), backend.PluginContext{ diff --git a/pkg/tsdb/cloudwatch/test_utils.go b/pkg/tsdb/cloudwatch/test_utils.go index 0d2683b19d4..26f7b8d3155 100644 --- a/pkg/tsdb/cloudwatch/test_utils.go +++ b/pkg/tsdb/cloudwatch/test_utils.go @@ -209,7 +209,8 @@ func testInstanceManager(pageLimit int) instancemgmt.InstanceManager { Region: "us-east-1", }, GrafanaSettings: awsds.AuthSettings{ListMetricsPageLimit: pageLimit}, - }}, nil + }, + sessions: &fakeSessionCache{}}, nil })) } diff --git a/pkg/tsdb/cloudwatch/time_series_query_test.go b/pkg/tsdb/cloudwatch/time_series_query_test.go index 9945211aefd..d1a1d13b47c 100644 --- a/pkg/tsdb/cloudwatch/time_series_query_test.go +++ b/pkg/tsdb/cloudwatch/time_series_query_test.go @@ -27,7 +27,7 @@ import ( ) func TestTimeSeriesQuery(t *testing.T) { - executor := newExecutor(nil, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(defaultTestInstanceManager(), log.NewNullLogger()) now := time.Now() origNewCWClient := NewCWClient @@ -53,7 +53,7 @@ func TestTimeSeriesQuery(t *testing.T) { im := defaultTestInstanceManager() - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) resp, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -147,19 +147,18 @@ func Test_executeTimeSeriesQuery_getCWClient_is_called_once_per_region_and_GetMe return &mockMetricClient } - im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil - }) - t.Run("Queries with the same region should call GetSession with that region 1 time and call GetMetricDataWithContext 1 time", func(t *testing.T) { mockSessionCache := &mockSessionCache{} mockSessionCache.On("GetSession", mock.MatchedBy( func(config awsds.SessionConfig) bool { return config.Settings.Region == "us-east-1" })). // region from queries is asserted here Return(&session.Session{Config: &aws.Config{}}, nil).Once() + im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { + return DataSource{Settings: models.CloudWatchSettings{}, sessions: mockSessionCache}, nil + }) mockMetricClient = mocks.MetricsAPI{} mockMetricClient.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(nil, nil) - executor := newExecutor(im, mockSessionCache, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -207,10 +206,15 @@ func Test_executeTimeSeriesQuery_getCWClient_is_called_once_per_region_and_GetMe sessionCache.On("GetSession", mock.MatchedBy( func(config awsds.SessionConfig) bool { return config.Settings.Region == "us-east-2" })). Return(&session.Session{Config: &aws.Config{}}, nil, nil).Once() + + im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { + return DataSource{Settings: models.CloudWatchSettings{}, sessions: sessionCache}, nil + }) + mockMetricClient = mocks.MetricsAPI{} mockMetricClient.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(nil, nil) - executor := newExecutor(im, sessionCache, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -337,13 +341,13 @@ func Test_QueryData_timeSeriesQuery_GetMetricDataWithContext(t *testing.T) { } im := datasource.NewInstanceManager(func(ctx context.Context, s backend.DataSourceInstanceSettings) (instancemgmt.Instance, error) { - return DataSource{Settings: models.CloudWatchSettings{}}, nil + return DataSource{Settings: models.CloudWatchSettings{}, sessions: &fakeSessionCache{}}, nil }) t.Run("passes query label as GetMetricData label", func(t *testing.T) { api = mocks.MetricsAPI{} api.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatch.GetMetricDataOutput{}, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) query := newTestQuery(t, queryParameters{ Label: aws.String("${PROP('Period')} some words ${PROP('Dim.InstanceId')}"), }) @@ -382,7 +386,7 @@ func Test_QueryData_timeSeriesQuery_GetMetricDataWithContext(t *testing.T) { t.Run(name, func(t *testing.T) { api = mocks.MetricsAPI{} api.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatch.GetMetricDataOutput{}, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}}, @@ -433,7 +437,7 @@ func Test_QueryData_response_data_frame_name_is_always_response_label(t *testing }}, nil) im := defaultTestInstanceManager() - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) t.Run("where user defines search expression", func(t *testing.T) { query := newTestQuery(t, queryParameters{ @@ -590,7 +594,7 @@ func TestTimeSeriesQuery_CrossAccountQuerying(t *testing.T) { t.Run("should call GetMetricDataInput with AccountId nil when no AccountId is provided", func(t *testing.T) { api = mocks.MetricsAPI{} api.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatch.GetMetricDataOutput{}, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ @@ -631,7 +635,7 @@ func TestTimeSeriesQuery_CrossAccountQuerying(t *testing.T) { t.Run("should call GetMetricDataInput with AccountId nil when feature flag is false", func(t *testing.T) { api = mocks.MetricsAPI{} api.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatch.GetMetricDataOutput{}, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(context.Background(), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -672,7 +676,7 @@ func TestTimeSeriesQuery_CrossAccountQuerying(t *testing.T) { t.Run("should call GetMetricDataInput with AccountId in a MetricStat query", func(t *testing.T) { api = mocks.MetricsAPI{} api.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatch.GetMetricDataOutput{}, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{}, @@ -713,7 +717,7 @@ func TestTimeSeriesQuery_CrossAccountQuerying(t *testing.T) { t.Run("should GetMetricDataInput with AccountId in an inferred search expression query", func(t *testing.T) { api = mocks.MetricsAPI{} api.On("GetMetricDataWithContext", mock.Anything, mock.Anything, mock.Anything).Return(&cloudwatch.GetMetricDataOutput{}, nil) - executor := newExecutor(im, &fakeSessionCache{}, log.NewNullLogger()) + executor := newExecutor(im, log.NewNullLogger()) _, err := executor.QueryData(contextWithFeaturesEnabled(features.FlagCloudWatchCrossAccountQuerying), &backend.QueryDataRequest{ PluginContext: backend.PluginContext{ DataSourceInstanceSettings: &backend.DataSourceInstanceSettings{},