Plugins: Support for distributed tracing in backend plugins SDK (#63714)

* Tracing: Pass OTLP address and propagation format to plugins

* Fix unit tests

* Fix indentation

* Fix plugin manager integration tests

* Goimports

* Pass plugin version to plugins

* Do not add GF_PLUGIN_VERSION if plugin version is not set, add tests

* Allow disabling plugins distributed tracing on a per-plugin basis

* Moved disabled plugins to tracing.opentelemetry config section

* Pre-allocate DisabledPlugins map to the correct size

* Moved disable tracing setting flags in plugin settings

* Renamed plugin env vars for tracing endpoint and propagation

* Fix plugin initializer tests

* Refactoring: Moved OpentelemetryCfg from pkg/infra to pkg/plugins

* Changed GetSection to Section in parseSettingsOpentelemetry

* Add tests for NewOpentelemetryCfg

* Fix test case names in TestNewOpentelemetryCfg

* OpenTelemetry: Remove redundant error checks

pkg/plugins/config/config.go

@@ -1,6 +1,7 @@
 package config
 
 import (
+	"fmt"
 	"strings"
 
 	"github.com/grafana/grafana-azure-sdk-go/azsettings"
@@ -31,13 +32,15 @@ type Cfg struct {
 	LogDatasourceRequests bool
 
 	PluginsCDNURLTemplate string
+
+	Opentelemetry OpentelemetryCfg
 }
 
-func ProvideConfig(settingProvider setting.Provider, grafanaCfg *setting.Cfg) *Cfg {
+func ProvideConfig(settingProvider setting.Provider, grafanaCfg *setting.Cfg) (*Cfg, error) {
 	return NewCfg(settingProvider, grafanaCfg)
 }
 
-func NewCfg(settingProvider setting.Provider, grafanaCfg *setting.Cfg) *Cfg {
+func NewCfg(settingProvider setting.Provider, grafanaCfg *setting.Cfg) (*Cfg, error) {
 	logger := log.New("plugin.cfg")
 
 	aws := settingProvider.Section("aws")
@@ -53,6 +56,10 @@ func NewCfg(settingProvider setting.Provider, grafanaCfg *setting.Cfg) *Cfg {
 		allowedUnsigned = strings.Split(settingProvider.KeyValue("plugins", "allow_loading_unsigned_plugins").Value(), ",")
 	}
 
+	otelCfg, err := NewOpentelemetryCfg(grafanaCfg)
+	if err != nil {
+		return nil, fmt.Errorf("new opentelemetry cfg: %w", err)
+	}
 	return &Cfg{
 		log:                     logger,
 		PluginsPath:             grafanaCfg.PluginsPath,
@@ -65,7 +72,8 @@ func NewCfg(settingProvider setting.Provider, grafanaCfg *setting.Cfg) *Cfg {
 		Azure:                   grafanaCfg.Azure,
 		LogDatasourceRequests:   grafanaCfg.PluginLogBackendRequests,
 		PluginsCDNURLTemplate:   grafanaCfg.PluginsCDNURLTemplate,
-	}
+		Opentelemetry:           otelCfg,
+	}, nil
 }
 
 func extractPluginSettings(settingProvider setting.Provider) setting.PluginSettings {

pkg/plugins/config/tracing.go

@@ -0,0 +1,38 @@
+package config
+
+import (
+	"fmt"
+
+	"github.com/grafana/grafana/pkg/infra/tracing"
+	"github.com/grafana/grafana/pkg/setting"
+)
+
+const otlpExporter string = "otlp"
+
+// OpentelemetryCfg contains the Opentelemetry address and propagation config values.
+// This is used to export the Opentelemetry (OTLP) config without exposing the whole *setting.Cfg.
+type OpentelemetryCfg struct {
+	Address     string
+	Propagation string
+}
+
+// IsEnabled returns true if OTLP tracing is enabled (address set)
+func (c OpentelemetryCfg) IsEnabled() bool {
+	return c.Address != ""
+}
+
+// NewOpentelemetryCfg creates a new OpentelemetryCfg based on the provided Grafana config.
+// If Opentelemetry (OTLP) is disabled, a zero-value OpentelemetryCfg is returned.
+func NewOpentelemetryCfg(grafanaCfg *setting.Cfg) (OpentelemetryCfg, error) {
+	ots, err := tracing.ParseSettingsOpentelemetry(grafanaCfg)
+	if err != nil {
+		return OpentelemetryCfg{}, fmt.Errorf("parse settings: %w", err)
+	}
+	if ots.Enabled != otlpExporter {
+		return OpentelemetryCfg{}, nil
+	}
+	return OpentelemetryCfg{
+		Address:     ots.Address,
+		Propagation: ots.Propagation,
+	}, nil
+}

pkg/plugins/config/tracing_test.go

@@ -0,0 +1,50 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/grafana/grafana/pkg/setting"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestNewOpentelemetryCfg(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		cfg := setting.NewCfg()
+
+		otelCfg, err := NewOpentelemetryCfg(cfg)
+		require.NoError(t, err)
+		assert.False(t, otelCfg.IsEnabled(), "otel should be disabled")
+		assert.Empty(t, otelCfg.Address)
+		assert.Empty(t, otelCfg.Propagation)
+	})
+
+	t.Run("enabled", func(t *testing.T) {
+		for _, tc := range []struct {
+			name        string
+			propagation string
+		}{
+			{"empty", ""},
+			{"jaeger", "jaeger"},
+			{"w3c", "w3c"},
+			{"multiple", "jaeger,w3c"},
+		} {
+			t.Run(tc.name, func(t *testing.T) {
+				const address = "127.0.0.1:4317"
+
+				cfg := setting.NewCfg()
+				otlpSect := cfg.Raw.Section("tracing.opentelemetry.otlp")
+				otlpSect.Key("address").SetValue(address)
+				if tc.propagation != "" {
+					otlpSect.Key("propagation").SetValue(tc.propagation)
+				}
+
+				otelCfg, err := NewOpentelemetryCfg(cfg)
+				require.NoError(t, err)
+				assert.True(t, otelCfg.IsEnabled(), "otel should be enabled")
+				assert.Equal(t, address, otelCfg.Address)
+				assert.Equal(t, tc.propagation, otelCfg.Propagation)
+			})
+		}
+	})
+}