CloudWatch: Move SessionCache onto the instance (#83278)

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{},

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
 	}

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`,

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)
 

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{},

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"},

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
 

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",

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{

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
 	}))
 }
 

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{},