add debug logs to highlight provider behaviour (#1432)

Author: wbrowne

backend/app/instance_provider.go

@@ -48,17 +48,10 @@ func (ip *instanceProvider) GetKey(ctx context.Context, pluginContext backend.Pl
 return nil, errors.New("app instance settings cannot be nil")
 }
 
-// The instance key generated for app plugins should include both plugin ID, and the OrgID, since for a single
-// Grafana instance there might be different orgs using the same plugin.
-defaultKey := fmt.Sprintf("%s#%v", pluginContext.PluginID, pluginContext.OrgID)
-if tID := tenant.IDFromContext(ctx); tID != "" {
-return fmt.Sprintf("%s#%s", tID, defaultKey), nil
-}
-
-return defaultKey, nil
+return instanceKey(ctx, pluginContext), nil
 }
 
-func (ip *instanceProvider) NeedsUpdate(_ context.Context, pluginContext backend.PluginContext, cachedInstance instancemgmt.CachedInstance) bool {
+func (ip *instanceProvider) NeedsUpdate(ctx context.Context, pluginContext backend.PluginContext, cachedInstance instancemgmt.CachedInstance) bool {
 curConfig := pluginContext.GrafanaConfig
 cachedConfig := cachedInstance.PluginContext.GrafanaConfig
 configUpdated := !cachedConfig.Equal(curConfig)
@@ -67,9 +60,33 @@ func (ip *instanceProvider) NeedsUpdate(_ context.Context, pluginContext backend
 curAppSettings := pluginContext.AppInstanceSettings
 appUpdated := !curAppSettings.Updated.Equal(cachedAppSettings.Updated)
 
+if appUpdated || configUpdated {
+logger := backend.Logger.FromContext(ctx)
+
+ik := instanceKey(ctx, pluginContext)
+if appUpdated {
+logger.Debug("App instance needs update: app settings changed", "key", ik)
+}
+if configUpdated {
+logger.Debug("App instance needs update: config changed", "key", ik, "diff", curConfig.Diff(cachedConfig))
+}
+}
+
 return appUpdated || configUpdated
 }
 
 func (ip *instanceProvider) NewInstance(ctx context.Context, pluginContext backend.PluginContext) (instancemgmt.Instance, error) {
+backend.Logger.FromContext(ctx).Debug("App instance created", "key", instanceKey(ctx, pluginContext))
 return ip.factory(ctx, *pluginContext.AppInstanceSettings)
 }
+
+func instanceKey(ctx context.Context, pluginContext backend.PluginContext) string {
+// The instance key generated for app plugins should include both plugin ID, and the OrgID, since for a single
+// Grafana instance there might be different orgs using the same plugin.
+defaultKey := fmt.Sprintf("%s#%v", pluginContext.PluginID, pluginContext.OrgID)
+if tID := tenant.IDFromContext(ctx); tID != "" {
+return fmt.Sprintf("%s#%s", tID, defaultKey)
+}
+
+return defaultKey
+}

backend/config.go

@@ -98,6 +98,48 @@ func (c *GrafanaCfg) Equal(c2 *GrafanaCfg) bool {
 return true
 }
 
+// Diff returns the names of config fields that differ between this config and c2.
+// Returns field names for added, removed, or changed values.
+// Always returns a slice, never nil.
+func (c *GrafanaCfg) Diff(c2 *GrafanaCfg) []string {
+if c == nil && c2 == nil {
+return []string{}
+}
+if c == nil {
+var keys []string
+for k := range c2.config {
+keys = append(keys, k)
+}
+return keys
+}
+if c2 == nil {
+var keys []string
+for k := range c.config {
+keys = append(keys, k)
+}
+return keys
+}
+
+var changed []string
+keys := make(map[string]bool)
+for k := range c.config {
+keys[k] = true
+}
+for k := range c2.config {
+keys[k] = true
+}
+
+for key := range keys {
+v1, ok1 := c.config[key]
+v2, ok2 := c2.config[key]
+if ok1 != ok2 || v1 != v2 {
+changed = append(changed, key)
+}
+}
+
+return changed
+}
+
 // ProxyHash returns the last four characters of the base64-encoded
 // PDC client key contents, if present, for use in datasource instance
 // caching. The contents should be PEM-encoded, so we try to PEM-decode

backend/config_test.go

@@ -375,6 +375,133 @@ func randomProxyContents() []byte {
 
 var b64chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/+"
 
+func TestGrafanaCfg_Diff(t *testing.T) {
+t.Run("both configs nil should return empty slice", func(t *testing.T) {
+var cfg1, cfg2 *GrafanaCfg
+diff := cfg1.Diff(cfg2)
+require.Empty(t, diff)
+require.NotNil(t, diff)
+})
+
+t.Run("one config nil should return keys from other config", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{"key1": "value1", "key2": "value2"})
+var cfg2 *GrafanaCfg
+
+diff1 := cfg1.Diff(cfg2) // cfg1 has keys, cfg2 is nil
+diff2 := cfg2.Diff(cfg1) // cfg2 is nil, cfg1 has keys
+
+require.Len(t, diff1, 2)
+require.Contains(t, diff1, "key1")
+require.Contains(t, diff1, "key2")
+
+require.Len(t, diff2, 2)
+require.Contains(t, diff2, "key1")
+require.Contains(t, diff2, "key2")
+})
+
+t.Run("one config empty should return keys from other config", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{"key1": "value1", "key2": "value2"})
+cfg2 := NewGrafanaCfg(map[string]string{})
+
+diff1 := cfg1.Diff(cfg2) // cfg1 has keys, cfg2 is empty
+diff2 := cfg2.Diff(cfg1) // cfg2 is empty, cfg1 has keys
+
+require.Len(t, diff1, 2)
+require.Contains(t, diff1, "key1")
+require.Contains(t, diff1, "key2")
+
+require.Len(t, diff2, 2)
+require.Contains(t, diff2, "key1")
+require.Contains(t, diff2, "key2")
+})
+
+t.Run("empty configs should return empty slice", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{})
+cfg2 := NewGrafanaCfg(map[string]string{})
+
+diff := cfg1.Diff(cfg2)
+require.Empty(t, diff)
+})
+
+t.Run("identical configs should return empty slice", func(t *testing.T) {
+config := map[string]string{
+"key1": "value1",
+"key2": "value2",
+"key3": "value3",
+}
+cfg1 := NewGrafanaCfg(config)
+cfg2 := NewGrafanaCfg(config)
+
+diff := cfg1.Diff(cfg2)
+require.Empty(t, diff)
+})
+
+t.Run("different values should return changed keys", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{
+"key1": "value1",
+"key2": "value2",
+})
+cfg2 := NewGrafanaCfg(map[string]string{
+"key1": "different_value",
+"key2": "value2",
+})
+
+diff := cfg1.Diff(cfg2)
+require.Len(t, diff, 1)
+require.Contains(t, diff, "key1")
+})
+
+t.Run("added keys should be detected", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{
+"key1": "value1",
+"key2": "value2",
+"key3": "value3",
+})
+cfg2 := NewGrafanaCfg(map[string]string{
+"key1": "value1",
+"key2": "value2",
+})
+
+diff := cfg1.Diff(cfg2)
+require.Len(t, diff, 1)
+require.Contains(t, diff, "key3")
+})
+
+t.Run("removed keys should be detected", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{
+"key1": "value1",
+})
+cfg2 := NewGrafanaCfg(map[string]string{
+"key1": "value1",
+"key2": "value2",
+})
+
+diff := cfg1.Diff(cfg2)
+require.Len(t, diff, 1)
+require.Contains(t, diff, "key2")
+})
+
+t.Run("multiple changes should be detected", func(t *testing.T) {
+cfg1 := NewGrafanaCfg(map[string]string{
+"unchanged": "same_value",
+"modified": "old_value",
+"removed": "will_be_removed",
+})
+cfg2 := NewGrafanaCfg(map[string]string{
+"unchanged": "same_value",
+"modified": "new_value",
+"added": "new_key",
+})
+
+diff := cfg1.Diff(cfg2)
+require.Len(t, diff, 3)
+require.Contains(t, diff, "modified")
+require.Contains(t, diff, "removed")
+require.Contains(t, diff, "added")
+require.NotContains(t, diff, "unchanged")
+})
+}
+
 func BenchmarkProxyHash(b *testing.B) {
 count := 0
 kBytes := randomProxyContents()

backend/datasource/instance_provider.go

@@ -33,7 +33,7 @@ func NewInstanceManager(fn InstanceFactoryFunc) instancemgmt.InstanceManager {
 return instancemgmt.New(ip)
 }
 
-// NewInstanceProvider create a new data source instance provuder,
+// NewInstanceProvider create a new data source instance provider,
 //
 // The instance provider is responsible for providing cache keys for data source instances,
 // creating new instances when needed and invalidating cached instances when they have been
@@ -59,14 +59,10 @@ func (ip *instanceProvider) GetKey(ctx context.Context, pluginContext backend.Pl
 return nil, errors.New("data source instance settings cannot be nil")
 }
 
-dsID := pluginContext.DataSourceInstanceSettings.ID
-proxyHash := pluginContext.GrafanaConfig.ProxyHash()
-tenantID := tenant.IDFromContext(ctx)
-
-return fmt.Sprintf("%d#%s#%s", dsID, tenantID, proxyHash), nil
+return instanceKey(ctx, pluginContext), nil
 }
 
-func (ip *instanceProvider) NeedsUpdate(_ context.Context, pluginContext backend.PluginContext, cachedInstance instancemgmt.CachedInstance) bool {
+func (ip *instanceProvider) NeedsUpdate(ctx context.Context, pluginContext backend.PluginContext, cachedInstance instancemgmt.CachedInstance) bool {
 curConfig := pluginContext.GrafanaConfig
 cachedConfig := cachedInstance.PluginContext.GrafanaConfig
 configUpdated := !cachedConfig.Equal(curConfig)
@@ -75,10 +71,31 @@ func (ip *instanceProvider) NeedsUpdate(_ context.Context, pluginContext backend
 cachedDataSourceSettings := cachedInstance.PluginContext.DataSourceInstanceSettings
 dsUpdated := !curDataSourceSettings.Updated.Equal(cachedDataSourceSettings.Updated)
 
+if dsUpdated || configUpdated {
+logger := backend.Logger.FromContext(ctx)
+
+ik := instanceKey(ctx, pluginContext)
+if dsUpdated {
+logger.Debug("Datasource instance needs update: datasource settings changed", "key", ik)
+}
+if configUpdated {
+logger.Debug("Datasource instance needs update: config changed", "key", ik, "diff", curConfig.Diff(cachedConfig))
+}
+}
+
 return dsUpdated || configUpdated
 }
 
 func (ip *instanceProvider) NewInstance(ctx context.Context, pluginContext backend.PluginContext) (instancemgmt.Instance, error) {
 datasourceInstancesCreated.Inc()
+backend.Logger.FromContext(ctx).Debug("Datasource instance created", "key", instanceKey(ctx, pluginContext))
 return ip.factory(ctx, *pluginContext.DataSourceInstanceSettings)
 }
+
+func instanceKey(ctx context.Context, pluginContext backend.PluginContext) string {
+dsID := pluginContext.DataSourceInstanceSettings.ID
+tenantID := tenant.IDFromContext(ctx)
+proxyHash := pluginContext.GrafanaConfig.ProxyHash()
+
+return fmt.Sprintf("%d#%s#%s", dsID, tenantID, proxyHash)
+}