create instance manager at runtime

Author: wbrowne

backend/app/instance_provider.go

@@ -13,13 +13,13 @@ import (
 // InstanceFactoryFunc factory method for creating app instances.
 type InstanceFactoryFunc func(ctx context.Context, settings backend.AppInstanceSettings) (instancemgmt.Instance, error)
 
-// NewInstanceManager creates a new app instance manager,
+// NewInstanceManager creates a new app instance manager.
 //
 // This is a helper method for calling NewInstanceProvider and creating a new instancemgmt.InstanceProvider,
-// and providing that to instancemgmt.New.
+// and providing that to instancemgmt.NewContextAwareInstanceManager.
 func NewInstanceManager(fn InstanceFactoryFunc) instancemgmt.InstanceManager {
 	ip := NewInstanceProvider(fn)
-	return instancemgmt.New(ip)
+	return instancemgmt.NewContextAwareInstanceManager(ip)
 }
 
 // NewInstanceProvider create a new app instance provider,

backend/datasource/manage.go

@@ -6,7 +6,6 @@ import (
 	"os"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
-	"github.com/grafana/grafana-plugin-sdk-go/backend/instancemgmt"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/tracing"
 	"github.com/grafana/grafana-plugin-sdk-go/internal/automanagement"
 	"github.com/grafana/grafana-plugin-sdk-go/internal/buildinfo"
@@ -28,11 +27,6 @@ type ManageOpts struct {
 
 	// Stateless query conversion handler
 	QueryConversionHandler backend.QueryConversionHandler
-
-	// UseTTLInstanceManager controls whether to use the TTL-based instance manager.
-	// When true, instances will be automatically evicted from the cache after a configurable TTL.
-	// Default is false, which uses the standard instance manager.
-	UseTTLInstanceManager bool
 }
 
 // Manage starts serving the data source over gPRC with automatic instance management.
@@ -53,16 +47,7 @@ func Manage(pluginID string, instanceFactory InstanceFactoryFunc, opts ManageOpt
 		return fmt.Errorf("setup tracer: %w", err)
 	}
 
-	ip := NewInstanceProvider(instanceFactory)
-
-	var im instancemgmt.InstanceManager
-	if opts.UseTTLInstanceManager {
-		im = instancemgmt.NewTTLInstanceManager(ip)
-	} else {
-		im = instancemgmt.New(ip)
-	}
-
-	handler := automanagement.NewManager(im)
+	handler := automanagement.NewManager(NewInstanceManager(instanceFactory))
 	return backend.Manage(pluginID, backend.ServeOpts{
 		CheckHealthHandler:     handler,
 		CallResourceHandler:    handler,

backend/instancemgmt/context_aware_manager.go

@@ -0,0 +1,53 @@
+package instancemgmt
+
+import (
+	"context"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/experimental/featuretoggles"
+)
+
+// NewContextAwareInstanceManager creates a new instance manager that dynamically selects
+// between standard and TTL instance managers based on feature toggles from the Grafana config.
+func NewContextAwareInstanceManager(provider InstanceProvider) InstanceManager {
+	return &contextAwareInstanceManager{
+		provider:        provider,
+		standardManager: New(provider),
+		ttlManager:      NewTTLInstanceManager(provider),
+	}
+}
+
+// contextAwareInstanceManager is a wrapper that dynamically selects the appropriate
+// instance manager implementation based on feature toggles in the context.
+type contextAwareInstanceManager struct {
+	provider        InstanceProvider
+	standardManager InstanceManager
+	ttlManager      InstanceManager
+}
+
+// selectManager returns the appropriate instance manager based on the feature toggle
+// from the Grafana config in the plugin context.
+func (c *contextAwareInstanceManager) selectManager(_ context.Context, pluginContext backend.PluginContext) InstanceManager {
+	// Check if TTL instance manager feature toggle is enabled
+	if pluginContext.GrafanaConfig != nil {
+		featureToggles := pluginContext.GrafanaConfig.FeatureToggles()
+		if featureToggles.IsEnabled(featuretoggles.TTLInstanceManager) {
+			return c.ttlManager
+		}
+	}
+
+	// Default to standard instance manager
+	return c.standardManager
+}
+
+// Get returns an Instance using the appropriate manager based on feature toggles.
+func (c *contextAwareInstanceManager) Get(ctx context.Context, pluginContext backend.PluginContext) (Instance, error) {
+	manager := c.selectManager(ctx, pluginContext)
+	return manager.Get(ctx, pluginContext)
+}
+
+// Do provides an Instance as argument to fn using the appropriate manager based on feature toggles.
+func (c *contextAwareInstanceManager) Do(ctx context.Context, pluginContext backend.PluginContext, fn InstanceCallbackFunc) error {
+	manager := c.selectManager(ctx, pluginContext)
+	return manager.Do(ctx, pluginContext, fn)
+}

backend/instancemgmt/context_aware_manager_test.go

@@ -0,0 +1,115 @@
+package instancemgmt
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/experimental/featuretoggles"
+)
+
+func TestContextAwareInstanceManager(t *testing.T) {
+	ctx := context.Background()
+	tip := &testInstanceProvider{}
+	im := NewContextAwareInstanceManager(tip)
+
+	t.Run("Should use standard manager when feature toggle is disabled", func(t *testing.T) {
+		pCtx := backend.PluginContext{
+			OrgID: 1,
+			AppInstanceSettings: &backend.AppInstanceSettings{
+				Updated: time.Now(),
+			},
+			GrafanaConfig: backend.NewGrafanaCfg(map[string]string{
+				featuretoggles.EnabledFeatures: "",
+			}),
+		}
+
+		manager := im.(*contextAwareInstanceManager).selectManager(ctx, pCtx)
+		require.IsType(t, &instanceManager{}, manager)
+	})
+
+	t.Run("Should use TTL manager when feature toggle is enabled", func(t *testing.T) {
+		pCtx := backend.PluginContext{
+			OrgID: 1,
+			AppInstanceSettings: &backend.AppInstanceSettings{
+				Updated: time.Now(),
+			},
+			GrafanaConfig: backend.NewGrafanaCfg(map[string]string{
+				featuretoggles.EnabledFeatures: featuretoggles.TTLInstanceManager,
+			}),
+		}
+
+		manager := im.(*contextAwareInstanceManager).selectManager(ctx, pCtx)
+		require.IsType(t, &instanceManagerWithTTL{}, manager)
+	})
+
+	t.Run("Should use standard manager when GrafanaConfig is nil", func(t *testing.T) {
+		pCtx := backend.PluginContext{
+			OrgID: 1,
+			AppInstanceSettings: &backend.AppInstanceSettings{
+				Updated: time.Now(),
+			},
+			GrafanaConfig: nil,
+		}
+
+		manager := im.(*contextAwareInstanceManager).selectManager(ctx, pCtx)
+		require.IsType(t, &instanceManager{}, manager)
+	})
+
+	t.Run("Should use TTL manager when feature toggle is enabled with other flags", func(t *testing.T) {
+		pCtx := backend.PluginContext{
+			OrgID: 1,
+			AppInstanceSettings: &backend.AppInstanceSettings{
+				Updated: time.Now(),
+			},
+			GrafanaConfig: backend.NewGrafanaCfg(map[string]string{
+				featuretoggles.EnabledFeatures: "someOtherFlag," + featuretoggles.TTLInstanceManager + ",anotherFlag",
+			}),
+		}
+
+		manager := im.(*contextAwareInstanceManager).selectManager(ctx, pCtx)
+		require.IsType(t, &instanceManagerWithTTL{}, manager)
+	})
+
+	t.Run("Should delegate Get calls correctly", func(t *testing.T) {
+		// Test with TTL manager enabled
+		pCtx := backend.PluginContext{
+			OrgID: 1,
+			AppInstanceSettings: &backend.AppInstanceSettings{
+				Updated: time.Now(),
+			},
+			GrafanaConfig: backend.NewGrafanaCfg(map[string]string{
+				featuretoggles.EnabledFeatures: featuretoggles.TTLInstanceManager,
+			}),
+		}
+
+		instance, err := im.Get(ctx, pCtx)
+		require.NoError(t, err)
+		require.NotNil(t, instance)
+		require.Equal(t, pCtx.OrgID, instance.(*testInstance).orgID)
+	})
+
+	t.Run("Should delegate Do calls correctly", func(t *testing.T) {
+		// Test with standard manager (no feature toggle)
+		pCtx := backend.PluginContext{
+			OrgID: 2,
+			AppInstanceSettings: &backend.AppInstanceSettings{
+				Updated: time.Now(),
+			},
+			GrafanaConfig: backend.NewGrafanaCfg(map[string]string{
+				featuretoggles.EnabledFeatures: "",
+			}),
+		}
+
+		var receivedInstance *testInstance
+		err := im.Do(ctx, pCtx, func(instance *testInstance) {
+			receivedInstance = instance
+		})
+		require.NoError(t, err)
+		require.NotNil(t, receivedInstance)
+		require.Equal(t, pCtx.OrgID, receivedInstance.orgID)
+	})
+}

backend/instancemgmt/doc.go

@@ -1,2 +1,19 @@
 // Package instancemgmt provides utilities for managing plugin instances.
+//
+// This package offers several instance manager implementations:
+//
+//  1. Standard Instance Manager (New): Uses sync.Map for caching instances
+//     and disposes them when they need updates.
+//
+//  2. TTL Instance Manager (NewTTLInstanceManager): Uses TTL-based caching
+//     that automatically evicts instances after a configurable time period.
+//
+//  3. Context-Aware Instance Manager (NewContextAwareInstanceManager):
+//     Dynamically selects between standard and TTL managers based on
+//     feature toggles from the Grafana config in the context.
+//
+// The context-aware manager checks the "ttlInstanceManager" feature toggle
+// from the Grafana configuration and automatically uses the appropriate
+// underlying implementation. This allows runtime switching without requiring
+// plugin restarts or static configuration.
 package instancemgmt

experimental/featuretoggles/featuretoggles.go

@@ -10,7 +10,7 @@ const (
 
 	// TTLInstanceManager is a feature toggle for enabling the TTL-based instance manager.
 	// When enabled, instances will be automatically evicted from the cache after a configurable TTL.
-	TTLInstanceManager = "ttlInstanceManager"
+	TTLInstanceManager = "ttlPluginInstanceManager"
 )
 
 // FeatureToggles can check if feature toggles are enabled on the Grafana instance.