Backend plugins: Refactor to allow shared contract between core and external…

Backend plugins: Refactor to allow shared contract between core and external backend plugins (#25472)

Refactor to allow shared contract between core and external backend plugins 
allowing core backend data sources in Grafana to be implemented in same 
way as an external backend plugin.
Use v0.67.0 of sdk.
Add tests for verifying plugin is restarted when process is killed.
Enable strict linting for backendplugin packages

.circleci/config.yml

@@ -828,9 +828,11 @@ jobs:
               -E varcheck -E goconst -E errcheck -E staticcheck ./pkg/...
             ./scripts/go/bin/revive -formatter stylish -config ./scripts/go/configs/revive.toml ./pkg/...
             ./scripts/go/bin/revive -formatter stylish -config ./scripts/go/configs/revive-strict.toml \
+              -exclude ./pkg/plugins/backendplugin/pluginextensionv2/... \
               ./pkg/services/alerting/... \
               ./pkg/services/provisioning/datasources/... \
-              ./pkg/services/provisioning/dashboards/...
+              ./pkg/services/provisioning/dashboards/... \
+              ./pkg/plugins/backendplugin/...
 
             ./scripts/go/bin/gosec -quiet -exclude=G104,G107,G108,G201,G202,G204,G301,G304,G401,G402,G501 \
               -conf=./scripts/go/configs/gosec.json ./pkg/...

Makefile

@@ -4,7 +4,7 @@
 
 -include local/Makefile
 
-.PHONY: all deps-go deps-js deps build-go build-server build-cli build-js build build-docker-dev build-docker-full lint-go gosec revive golangci-lint go-vet test-go test-js test run run-frontend clean devenv devenv-down revive-alerting protobuf help
+.PHONY: all deps-go deps-js deps build-go build-server build-cli build-js build build-docker-dev build-docker-full lint-go gosec revive golangci-lint go-vet test-go test-js test run run-frontend clean devenv devenv-down revive-strict protobuf help
 
 GO = GO111MODULE=on go
 GO_FILES ?= ./pkg/...
@@ -81,14 +81,16 @@ revive: scripts/go/bin/revive
 		-config ./scripts/go/configs/revive.toml \
 		$(GO_FILES)
 
-revive-alerting: scripts/go/bin/revive
-	@echo "lint alerting via revive"
+revive-strict: scripts/go/bin/revive
+	@echo "lint via revive (strict)"
 	@scripts/go/bin/revive \
 		-formatter stylish \
 		-config ./scripts/go/configs/revive-strict.toml \
+		-exclude ./pkg/plugins/backendplugin/pluginextensionv2/... \
 		./pkg/services/alerting/... \
 		./pkg/services/provisioning/datasources/... \
-		./pkg/services/provisioning/dashboards/...
+		./pkg/services/provisioning/dashboards/... \
+		./pkg/plugins/backendplugin/...
 
 scripts/go/bin/golangci-lint: scripts/go/go.mod
 	@cd scripts/go; \
@@ -116,7 +118,7 @@ go-vet:
 	@echo "lint via go vet"
 	@$(GO) vet $(GO_FILES)
 
-lint-go: go-vet golangci-lint revive revive-alerting gosec ## Run all code checks for backend.
+lint-go: go-vet golangci-lint revive revive-strict gosec ## Run all code checks for backend.
 
 # with disabled SC1071 we are ignored some TCL,Expect `/usr/bin/env expect` scripts
 shellcheck: $(SH_FILES) ## Run checks for shell scripts.

go.mod

@@ -30,7 +30,7 @@ require (
 	github.com/gorilla/websocket v1.4.1
 	github.com/gosimple/slug v1.4.2
 	github.com/grafana/grafana-plugin-model v0.0.0-20190930120109-1fc953a61fb4
-	github.com/grafana/grafana-plugin-sdk-go v0.66.0
+	github.com/grafana/grafana-plugin-sdk-go v0.67.0
 	github.com/hashicorp/go-hclog v0.0.0-20180709165350-ff2cf002a8dd
 	github.com/hashicorp/go-plugin v1.2.2
 	github.com/hashicorp/go-version v1.1.0

go.sum

@@ -155,8 +155,8 @@ github.com/gosimple/slug v1.4.2 h1:jDmprx3q/9Lfk4FkGZtvzDQ9Cj9eAmsjzeQGp24PeiQ=
 github.com/gosimple/slug v1.4.2/go.mod h1:ER78kgg1Mv0NQGlXiDe57DpCyfbNywXXZ9mIorhxAf0=
 github.com/grafana/grafana-plugin-model v0.0.0-20190930120109-1fc953a61fb4 h1:SPdxCL9BChFTlyi0Khv64vdCW4TMna8+sxL7+Chx+Ag=
 github.com/grafana/grafana-plugin-model v0.0.0-20190930120109-1fc953a61fb4/go.mod h1:nc0XxBzjeGcrMltCDw269LoWF9S8ibhgxolCdA1R8To=
-github.com/grafana/grafana-plugin-sdk-go v0.66.0 h1:Tx8pchA74QUtxtN8moavf0FJoAZbnbW3Fe8RVfSKUoY=
-github.com/grafana/grafana-plugin-sdk-go v0.66.0/go.mod h1:w855JyiC5PDP3naWUJP0h/vY8RlzlE4+4fodyoXph+4=
+github.com/grafana/grafana-plugin-sdk-go v0.67.0 h1:2kvI9kROmp/pXRrDQSEvcpR7Zonle7HjXgOdH70P2bw=
+github.com/grafana/grafana-plugin-sdk-go v0.67.0/go.mod h1:w855JyiC5PDP3naWUJP0h/vY8RlzlE4+4fodyoXph+4=
 github.com/grpc-ecosystem/go-grpc-middleware v1.2.0 h1:0IKlLyQ3Hs9nDaiK5cSHAGmcQEIC8l2Ts1u6x5Dfrqg=
 github.com/grpc-ecosystem/go-grpc-middleware v1.2.0/go.mod h1:mJzapYve32yjrKlk9GbyCZHuPgZsrbyIbyKhSzOpg6s=
 github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho=

pkg/api/api.go

@@ -266,7 +266,7 @@ func (hs *HTTPServer) registerRoutes() {
 		apiRoute.Any("/datasources/proxy/:id", reqSignedIn, hs.ProxyDataSourceRequest)
 		apiRoute.Any("/datasources/:id/resources", hs.CallDatasourceResource)
 		apiRoute.Any("/datasources/:id/resources/*", hs.CallDatasourceResource)
-		apiRoute.Any("/datasources/:id/health", hs.CheckDatasourceHealth)
+		apiRoute.Any("/datasources/:id/health", Wrap(hs.CheckDatasourceHealth))
 
 		// Folders
 		apiRoute.Group("/folders", func(folderRoute routing.RouteRegister) {

pkg/api/datasources.go

@@ -11,7 +11,6 @@ import (
 	"github.com/grafana/grafana/pkg/bus"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/plugins"
-	"github.com/grafana/grafana/pkg/plugins/backendplugin"
 	"github.com/grafana/grafana/pkg/plugins/datasource/wrapper"
 	"github.com/grafana/grafana/pkg/util"
 )
@@ -342,28 +341,25 @@ func convertModelToDtos(ds *models.DataSource) dtos.DataSource {
 
 // CheckDatasourceHealth sends a health check request to the plugin datasource
 // /api/datasource/:id/health
-func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) {
+func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) Response {
 	datasourceID := c.ParamsInt64("id")
 
 	ds, err := hs.DatasourceCache.GetDatasource(datasourceID, c.SignedInUser, c.SkipCache)
 	if err != nil {
 		if err == models.ErrDataSourceAccessDenied {
-			c.JsonApiErr(403, "Access denied to datasource", err)
-			return
+			return Error(403, "Access denied to datasource", err)
 		}
-		c.JsonApiErr(500, "Unable to load datasource metadata", err)
-		return
+		return Error(500, "Unable to load datasource metadata", err)
 	}
 
 	plugin, ok := hs.PluginManager.GetDatasource(ds.Type)
 	if !ok {
-		c.JsonApiErr(500, "Unable to find datasource plugin", err)
-		return
+		return Error(500, "Unable to find datasource plugin", err)
 	}
 
 	dsInstanceSettings, err := wrapper.ModelToInstanceSettings(ds)
 	if err != nil {
-		c.JsonApiErr(500, "Unable to get datasource model", err)
+		return Error(500, "Unable to get datasource model", err)
 	}
 	pCtx := backend.PluginContext{
 		User:                       wrapper.BackendUserFromSignedInUser(c.SignedInUser),
@@ -374,25 +370,7 @@ func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) {
 
 	resp, err := hs.BackendPluginManager.CheckHealth(c.Req.Context(), pCtx)
 	if err != nil {
-		if err == backendplugin.ErrPluginNotRegistered {
-			c.JsonApiErr(404, "Plugin not found", err)
-			return
-		}
-
-		// Return status unknown instead?
-		if err == backendplugin.ErrDiagnosticsNotSupported {
-			c.JsonApiErr(404, "Health check not implemented", err)
-			return
-		}
-
-		// Return status unknown or error instead?
-		if err == backendplugin.ErrHealthCheckFailed {
-			c.JsonApiErr(500, "Plugin health check failed", err)
-			return
-		}
-
-		c.JsonApiErr(500, "Plugin healthcheck returned an unknown error", err)
-		return
+		return translatePluginRequestErrorToAPIError(err)
 	}
 
 	payload := map[string]interface{}{
@@ -405,17 +383,15 @@ func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) {
 		var jsonDetails map[string]interface{}
 		err = json.Unmarshal(resp.JSONDetails, &jsonDetails)
 		if err != nil {
-			c.JsonApiErr(500, "Failed to unmarshal detailed response from backend plugin", err)
-			return
+			return Error(500, "Failed to unmarshal detailed response from backend plugin", err)
 		}
 
 		payload["details"] = jsonDetails
 	}
 
-	if resp.Status != backendplugin.HealthStatusOk {
-		c.JSON(503, payload)
-		return
+	if resp.Status != backend.HealthStatusOk {
+		return JSON(503, payload)
 	}
 
-	c.JSON(200, payload)
+	return JSON(200, payload)
 }

pkg/api/plugins.go

@@ -266,20 +266,12 @@ func (hs *HTTPServer) CollectPluginMetrics(c *models.ReqContext) Response {
 	pluginID := c.Params("pluginId")
 	plugin, exists := plugins.Plugins[pluginID]
 	if !exists {
-		return Error(404, "Plugin not found, no installed plugin with that id", nil)
+		return Error(404, "Plugin not found", nil)
 	}
 
 	resp, err := hs.BackendPluginManager.CollectMetrics(c.Req.Context(), plugin.Id)
 	if err != nil {
-		if err == backendplugin.ErrPluginNotRegistered {
-			return Error(404, "Plugin not found", err)
-		}
-
-		if err == backendplugin.ErrDiagnosticsNotSupported {
-			return Error(404, "Health check not implemented", err)
-		}
-
-		return Error(500, "Collect plugin metrics failed", err)
+		return translatePluginRequestErrorToAPIError(err)
 	}
 
 	headers := make(http.Header)
@@ -300,7 +292,7 @@ func (hs *HTTPServer) CheckHealth(c *models.ReqContext) Response {
 	pCtx, err := hs.getPluginContext(pluginID, c.SignedInUser)
 	if err != nil {
 		if err == ErrPluginNotFound {
-			return Error(404, "Plugin not found, no installed plugin with that id", nil)
+			return Error(404, "Plugin not found", nil)
 		}
 
 		return Error(500, "Failed to get plugin settings", err)
@@ -308,21 +300,7 @@ func (hs *HTTPServer) CheckHealth(c *models.ReqContext) Response {
 
 	resp, err := hs.BackendPluginManager.CheckHealth(c.Req.Context(), pCtx)
 	if err != nil {
-		if err == backendplugin.ErrPluginNotRegistered {
-			return Error(404, "Plugin not found", err)
-		}
-
-		// Return status unknown instead?
-		if err == backendplugin.ErrDiagnosticsNotSupported {
-			return Error(404, "Health check not implemented", err)
-		}
-
-		// Return status unknown or error instead?
-		if err == backendplugin.ErrHealthCheckFailed {
-			return Error(500, "Plugin health check failed", err)
-		}
-
-		return Error(500, "Plugin healthcheck returned an unknown error", err)
+		return translatePluginRequestErrorToAPIError(err)
 	}
 
 	payload := map[string]interface{}{
@@ -341,7 +319,7 @@ func (hs *HTTPServer) CheckHealth(c *models.ReqContext) Response {
 		payload["details"] = jsonDetails
 	}
 
-	if resp.Status != backendplugin.HealthStatusOk {
+	if resp.Status != backend.HealthStatusOk {
 		return JSON(503, payload)
 	}
 
@@ -357,7 +335,7 @@ func (hs *HTTPServer) CallResource(c *models.ReqContext) {
 	pCtx, err := hs.getPluginContext(pluginID, c.SignedInUser)
 	if err != nil {
 		if err == ErrPluginNotFound {
-			c.JsonApiErr(404, "Plugin not found, no installed plugin with that id", nil)
+			c.JsonApiErr(404, "Plugin not found", nil)
 			return
 		}
 
@@ -385,3 +363,23 @@ func (hs *HTTPServer) getCachedPluginSettings(pluginID string, user *models.Sign
 	hs.CacheService.Set(cacheKey, query.Result, time.Second*5)
 	return query.Result, nil
 }
+
+func translatePluginRequestErrorToAPIError(err error) Response {
+	if errors.Is(err, backendplugin.ErrPluginNotRegistered) {
+		return Error(404, "Plugin not found", err)
+	}
+
+	if errors.Is(err, backendplugin.ErrMethodNotImplemented) {
+		return Error(404, "Not found", err)
+	}
+
+	if errors.Is(err, backendplugin.ErrHealthCheckFailed) {
+		return Error(500, "Plugin health check failed", err)
+	}
+
+	if errors.Is(err, backendplugin.ErrPluginUnavailable) {
+		return Error(503, "Plugin unavailable", err)
+	}
+
+	return Error(500, "Plugin request failed", err)
+}

pkg/plugins/backendplugin/backend_plugin.go

-package backendplugin
-
-import (
-	"context"
-	"errors"
-	"net/http"
-
-	datasourceV1 "github.com/grafana/grafana-plugin-model/go/datasource"
-	rendererV1 "github.com/grafana/grafana-plugin-model/go/renderer"
-	"github.com/grafana/grafana-plugin-sdk-go/backend"
-	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
-	"github.com/grafana/grafana/pkg/infra/log"
-	"github.com/grafana/grafana/pkg/plugins/backendplugin/pluginextensionv2"
-	"github.com/grafana/grafana/pkg/util/errutil"
-	plugin "github.com/hashicorp/go-plugin"
-	"google.golang.org/grpc/codes"
-	"google.golang.org/grpc/status"
-)
-
-// BackendPlugin a registered backend plugin.
-type BackendPlugin struct {
-	id             string
-	executablePath string
-	managed        bool
-	clientFactory  func() *plugin.Client
-	client         *plugin.Client
-	logger         log.Logger
-	startFns       PluginStartFuncs
-	diagnostics    DiagnosticsPlugin
-	resource       ResourcePlugin
-}
-
-func (p *BackendPlugin) start(ctx context.Context) error {
-	p.client = p.clientFactory()
-	rpcClient, err := p.client.Client()
-	if err != nil {
-		return err
-	}
-
-	var legacyClient *LegacyClient
-	var client *Client
-
-	if p.client.NegotiatedVersion() > 1 {
-		rawDiagnostics, err := rpcClient.Dispense("diagnostics")
-		if err != nil {
-			return err
-		}
-
-		rawResource, err := rpcClient.Dispense("resource")
-		if err != nil {
-			return err
-		}
-
-		rawData, err := rpcClient.Dispense("data")
-		if err != nil {
-			return err
-		}
-
-		rawTransform, err := rpcClient.Dispense("transform")
-		if err != nil {
-			return err
-		}
-
-		rawRenderer, err := rpcClient.Dispense("renderer")
-		if err != nil {
-			return err
-		}
-
-		if rawDiagnostics != nil {
-			if plugin, ok := rawDiagnostics.(DiagnosticsPlugin); ok {
-				p.diagnostics = plugin
-			}
-		}
-
-		client = &Client{}
-		if rawResource != nil {
-			if plugin, ok := rawResource.(ResourcePlugin); ok {
-				p.resource = plugin
-				client.ResourcePlugin = plugin
-			}
-		}
-
-		if rawData != nil {
-			if plugin, ok := rawData.(DataPlugin); ok {
-				client.DataPlugin = plugin
-			}
-		}
-
-		if rawTransform != nil {
-			if plugin, ok := rawTransform.(TransformPlugin); ok {
-				client.TransformPlugin = plugin
-			}
-		}
-
-		if rawRenderer != nil {
-			if plugin, ok := rawRenderer.(pluginextensionv2.RendererPlugin); ok {
-				client.RendererPlugin = plugin
-			}
-		}
-	} else {
-		p.logger.Warn("Plugin uses a deprecated version of Grafana's backend plugin system which will be removed in a future release. " +
-			"Consider upgrading to a newer plugin version or reach out to the plugin repository/developer and request an upgrade.")
-		raw, err := rpcClient.Dispense(p.id)
-		if err != nil {
-			return err
-		}
-
-		legacyClient = &LegacyClient{}
-		if plugin, ok := raw.(datasourceV1.DatasourcePlugin); ok {
-			legacyClient.DatasourcePlugin = plugin
-		}
-
-		if plugin, ok := raw.(rendererV1.RendererPlugin); ok {
-			legacyClient.RendererPlugin = plugin
-		}
-	}
-
-	if legacyClient == nil && client == nil {
-		return errors.New("no compatible plugin implementation found")
-	}
-
-	if legacyClient != nil && p.startFns.OnLegacyStart != nil {
-		if err := p.startFns.OnLegacyStart(p.id, legacyClient, p.logger); err != nil {
-			return err
-		}
-	}
-
-	if client != nil && p.startFns.OnStart != nil {
-		if err := p.startFns.OnStart(p.id, client, p.logger); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func (p *BackendPlugin) stop() error {
-	if p.client != nil {
-		p.client.Kill()
-	}
-	return nil
-}
-
-// supportsDiagnostics return whether backend plugin supports diagnostics like metrics and health check.
-func (p *BackendPlugin) supportsDiagnostics() bool {
-	return p.diagnostics != nil
-}
-
-// CollectMetrics implements the collector.Collector interface.
-func (p *BackendPlugin) CollectMetrics(ctx context.Context) (*pluginv2.CollectMetricsResponse, error) {
-	if p.diagnostics == nil || p.client == nil || p.client.Exited() {
-		return &pluginv2.CollectMetricsResponse{
-			Metrics: &pluginv2.CollectMetricsResponse_Payload{},
-		}, nil
-	}
-
-	var res *pluginv2.CollectMetricsResponse
-	err := InstrumentPluginRequest(p.id, "metrics", func() error {
-		var innerErr error
-		res, innerErr = p.diagnostics.CollectMetrics(ctx, &pluginv2.CollectMetricsRequest{})
-
-		return innerErr
-	})
-
-	if err != nil {
-		if st, ok := status.FromError(err); ok {
-			if st.Code() == codes.Unimplemented {
-				return &pluginv2.CollectMetricsResponse{
-					Metrics: &pluginv2.CollectMetricsResponse_Payload{},
-				}, nil
-			}
-		}
-
-		return nil, err
-	}
-
-	return res, nil
-}
-
-var toProto = backend.ToProto()
-
-func (p *BackendPlugin) checkHealth(ctx context.Context, pCtx backend.PluginContext) (*pluginv2.CheckHealthResponse, error) {
-	if p.diagnostics == nil || p.client == nil || p.client.Exited() {
-		return &pluginv2.CheckHealthResponse{
-			Status: pluginv2.CheckHealthResponse_UNKNOWN,
-		}, nil
-	}
-
-	protoContext := toProto.PluginContext(pCtx)
-
-	var res *pluginv2.CheckHealthResponse
-	err := InstrumentPluginRequest(p.id, "checkhealth", func() error {
-		var innerErr error
-		res, innerErr = p.diagnostics.CheckHealth(ctx, &pluginv2.CheckHealthRequest{PluginContext: protoContext})
-		return innerErr
-	})
-
-	if err != nil {
-		if st, ok := status.FromError(err); ok {
-			if st.Code() == codes.Unimplemented {
-				return &pluginv2.CheckHealthResponse{
-					Status:  pluginv2.CheckHealthResponse_UNKNOWN,
-					Message: "Health check not implemented",
-				}, nil
-			}
-		}
-		return nil, err
-	}
-
-	return res, nil
-}
-
-func (p *BackendPlugin) callResource(ctx context.Context, req *backend.CallResourceRequest) (callResourceResultStream, error) {
-	p.logger.Debug("Calling resource", "path", req.Path, "method", req.Method)
-
-	if p.resource == nil || p.client == nil || p.client.Exited() {
-		return nil, errors.New("plugin not running, cannot call resource")
-	}
-
-	protoReq := toProto.CallResourceRequest(req)
-
-	protoStream, err := p.resource.CallResource(ctx, protoReq)
-	if err != nil {
-		if st, ok := status.FromError(err); ok {
-			if st.Code() == codes.Unimplemented {
-				return &singleCallResourceResult{
-					result: &CallResourceResult{
-						Status: http.StatusNotImplemented,
-					},
-				}, nil
-			}
-		}
-
-		return nil, errutil.Wrap("Failed to call resource", err)
-	}
-
-	return &callResourceResultStreamImpl{
-		stream: protoStream,
-	}, nil
-}

pkg/plugins/backendplugin/contracts.go

-package backendplugin
-
-import (
-	"strconv"
-
-	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
-)
-
-// HealthStatus is the status of the plugin.
-type HealthStatus int
-
-const (
-	// HealthStatusUnknown means the status of the plugin is unknown.
-	HealthStatusUnknown HealthStatus = iota
-	// HealthStatusOk means the status of the plugin is good.
-	HealthStatusOk
-	// HealthStatusError means the plugin is in an error state.
-	HealthStatusError
-)
-
-var healthStatusNames = map[int]string{
-	0: "UNKNOWN",
-	1: "OK",
-	2: "ERROR",
-}
-
-func (hs HealthStatus) String() string {
-	s, exists := healthStatusNames[int(hs)]
-	if exists {
-		return s
-	}
-	return strconv.Itoa(int(hs))
-}
-
-// CheckHealthResult check health result.
-type CheckHealthResult struct {
-	Status      HealthStatus
-	Message     string
-	JSONDetails []byte
-}
-
-func checkHealthResultFromProto(protoResp *pluginv2.CheckHealthResponse) *CheckHealthResult {
-	status := HealthStatusUnknown
-	switch protoResp.Status {
-	case pluginv2.CheckHealthResponse_ERROR:
-		status = HealthStatusError
-	case pluginv2.CheckHealthResponse_OK:
-		status = HealthStatusOk
-	}
-
-	return &CheckHealthResult{
-		Status:      status,
-		Message:     protoResp.Message,
-		JSONDetails: protoResp.JsonDetails,
-	}
-}
-
-func collectMetricsResultFromProto(protoResp *pluginv2.CollectMetricsResponse) *CollectMetricsResult {
-	var prometheusMetrics []byte
-
-	if protoResp.Metrics != nil {
-		prometheusMetrics = protoResp.Metrics.Prometheus
-	}
-
-	return &CollectMetricsResult{
-		PrometheusMetrics: prometheusMetrics,
-	}
-}
-
-// CollectMetricsResult collect metrics result.
-type CollectMetricsResult struct {
-	PrometheusMetrics []byte
-}
-
-// CallResourceResult call resource result.
-type CallResourceResult struct {
-	Status  int
-	Headers map[string][]string
-	Body    []byte
-}
-
-type callResourceResultStream interface {
-	Recv() (*CallResourceResult, error)
-	Close() error
-}
-
-type callResourceResultStreamImpl struct {
-	stream pluginv2.Resource_CallResourceClient
-}
-
-func (s *callResourceResultStreamImpl) Recv() (*CallResourceResult, error) {
-	protoResp, err := s.stream.Recv()
-	if err != nil {
-		return nil, err
-	}
-
-	respHeaders := map[string][]string{}
-	for key, values := range protoResp.Headers {
-		respHeaders[key] = values.Values
-	}
-
-	return &CallResourceResult{
-		Headers: respHeaders,
-		Body:    protoResp.Body,
-		Status:  int(protoResp.Code),
-	}, nil
-}
-
-func (s *callResourceResultStreamImpl) Close() error {
-	return s.stream.CloseSend()
-}
-
-type singleCallResourceResult struct {
-	result *CallResourceResult
-}
-
-func (s *singleCallResourceResult) Recv() (*CallResourceResult, error) {
-	return s.result, nil
-}
-
-func (s *singleCallResourceResult) Close() error {
-	return nil
-}

pkg/plugins/backendplugin/coreplugin/core_plugin.go

+package coreplugin
+
+import (
+	"context"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana/pkg/tsdb"
+)
+
+type corePlugin struct {
+	pluginID string
+	logger   log.Logger
+	backend.CheckHealthHandler
+	backend.CallResourceHandler
+	backend.QueryDataHandler
+}
+
+// New returns a new backendplugin.PluginFactoryFunc for creating a core (built-in) backendplugin.Plugin.
+func New(opts backend.ServeOpts) backendplugin.PluginFactoryFunc {
+	return backendplugin.PluginFactoryFunc(func(pluginID string, logger log.Logger, env []string) (backendplugin.Plugin, error) {
+		return &corePlugin{
+			pluginID:            pluginID,
+			logger:              logger,
+			CheckHealthHandler:  opts.CheckHealthHandler,
+			CallResourceHandler: opts.CallResourceHandler,
+			QueryDataHandler:    opts.QueryDataHandler,
+		}, nil
+	})
+}
+
+func (cp *corePlugin) PluginID() string {
+	return cp.pluginID
+}
+
+func (cp *corePlugin) Logger() log.Logger {
+	return cp.logger
+}
+
+func (cp *corePlugin) Start(ctx context.Context) error {
+	if cp.QueryDataHandler != nil {
+		tsdb.RegisterTsdbQueryEndpoint(cp.pluginID, func(dsInfo *models.DataSource) (tsdb.TsdbQueryEndpoint, error) {
+			return newQueryEndpointAdapter(cp.pluginID, cp.logger, backendplugin.InstrumentQueryDataHandler(cp.QueryDataHandler)), nil
+		})
+	}
+	return nil
+}
+
+func (cp *corePlugin) Stop(ctx context.Context) error {
+	return nil
+}
+
+func (cp *corePlugin) IsManaged() bool {
+	return false
+}
+
+func (cp *corePlugin) Exited() bool {
+	return false
+}
+
+func (cp *corePlugin) CollectMetrics(ctx context.Context) (*backend.CollectMetricsResult, error) {
+	return nil, backendplugin.ErrMethodNotImplemented
+}
+
+func (cp *corePlugin) CheckHealth(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
+	if cp.CheckHealthHandler != nil {
+		return cp.CheckHealthHandler.CheckHealth(ctx, req)
+	}
+
+	return nil, backendplugin.ErrMethodNotImplemented
+}
+
+func (cp *corePlugin) CallResource(ctx context.Context, req *backend.CallResourceRequest, sender backend.CallResourceResponseSender) error {
+	if cp.CallResourceHandler != nil {
+		return cp.CallResourceHandler.CallResource(ctx, req, sender)
+	}
+
+	return backendplugin.ErrMethodNotImplemented
+}

pkg/plugins/backendplugin/coreplugin/core_plugin_test.go

+package coreplugin_test
+
+import (
+	"context"
+	"testing"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin/coreplugin"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCorePlugin(t *testing.T) {
+	t.Run("New core plugin with empty opts should return expected values", func(t *testing.T) {
+		factory := coreplugin.New(backend.ServeOpts{})
+		p, err := factory("plugin", log.New("test"), nil)
+		require.NoError(t, err)
+		require.NotNil(t, p)
+		require.NoError(t, p.Start(context.Background()))
+		require.NoError(t, p.Stop(context.Background()))
+		require.False(t, p.IsManaged())
+		require.False(t, p.Exited())
+
+		_, err = p.CollectMetrics(context.Background())
+		require.Equal(t, backendplugin.ErrMethodNotImplemented, err)
+
+		_, err = p.CheckHealth(context.Background(), nil)
+		require.Equal(t, backendplugin.ErrMethodNotImplemented, err)
+
+		err = p.CallResource(context.Background(), nil, nil)
+		require.Equal(t, backendplugin.ErrMethodNotImplemented, err)
+	})
+
+	t.Run("New core plugin with handlers set in opts should return expected values", func(t *testing.T) {
+		checkHealthCalled := false
+		callResourceCalled := false
+		factory := coreplugin.New(backend.ServeOpts{
+			CheckHealthHandler: backend.CheckHealthHandlerFunc(func(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
+				checkHealthCalled = true
+				return nil, nil
+			}),
+			CallResourceHandler: backend.CallResourceHandlerFunc(func(ctx context.Context, req *backend.CallResourceRequest, sender backend.CallResourceResponseSender) error {
+				callResourceCalled = true
+				return nil
+			}),
+		})
+		p, err := factory("plugin", log.New("test"), nil)
+		require.NoError(t, err)
+		require.NotNil(t, p)
+		require.NoError(t, p.Start(context.Background()))
+		require.NoError(t, p.Stop(context.Background()))
+		require.False(t, p.IsManaged())
+		require.False(t, p.Exited())
+
+		_, err = p.CollectMetrics(context.Background())
+		require.Equal(t, backendplugin.ErrMethodNotImplemented, err)
+
+		_, err = p.CheckHealth(context.Background(), &backend.CheckHealthRequest{})
+		require.NoError(t, err)
+		require.True(t, checkHealthCalled)
+
+		err = p.CallResource(context.Background(), &backend.CallResourceRequest{}, nil)
+		require.NoError(t, err)
+		require.True(t, callResourceCalled)
+	})
+}

pkg/plugins/backendplugin/coreplugin/query_endpoint_adapter.go

+package coreplugin
+
+import (
+	"context"
+	"time"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/plugins/datasource/wrapper"
+	"github.com/grafana/grafana/pkg/tsdb"
+)
+
+func newQueryEndpointAdapter(pluginID string, logger log.Logger, handler backend.QueryDataHandler) tsdb.TsdbQueryEndpoint {
+	return &queryEndpointAdapter{
+		pluginID: pluginID,
+		logger:   logger,
+		handler:  handler,
+	}
+}
+
+type queryEndpointAdapter struct {
+	pluginID string
+	logger   log.Logger
+	handler  backend.QueryDataHandler
+}
+
+func modelToInstanceSettings(ds *models.DataSource) (*backend.DataSourceInstanceSettings, error) {
+	jsonDataBytes, err := ds.JsonData.MarshalJSON()
+	if err != nil {
+		return nil, err
+	}
+
+	return &backend.DataSourceInstanceSettings{
+		ID:                      ds.Id,
+		Name:                    ds.Name,
+		URL:                     ds.Url,
+		Database:                ds.Database,
+		User:                    ds.User,
+		BasicAuthEnabled:        ds.BasicAuth,
+		BasicAuthUser:           ds.BasicAuthUser,
+		JSONData:                jsonDataBytes,
+		DecryptedSecureJSONData: ds.DecryptedValues(),
+		Updated:                 ds.Updated,
+	}, nil
+}
+
+func (a *queryEndpointAdapter) Query(ctx context.Context, ds *models.DataSource, query *tsdb.TsdbQuery) (*tsdb.Response, error) {
+	instanceSettings, err := modelToInstanceSettings(ds)
+	if err != nil {
+		return nil, err
+	}
+
+	req := &backend.QueryDataRequest{
+		PluginContext: backend.PluginContext{
+			OrgID:                      ds.OrgId,
+			PluginID:                   a.pluginID,
+			User:                       wrapper.BackendUserFromSignedInUser(query.User),
+			DataSourceInstanceSettings: instanceSettings,
+		},
+		Queries: []backend.DataQuery{},
+	}
+
+	for _, q := range query.Queries {
+		modelJSON, err := q.Model.MarshalJSON()
+		if err != nil {
+			return nil, err
+		}
+		req.Queries = append(req.Queries, backend.DataQuery{
+			RefID:         q.RefId,
+			Interval:      time.Duration(q.IntervalMs) * time.Millisecond,
+			MaxDataPoints: q.MaxDataPoints,
+			TimeRange: backend.TimeRange{
+				From: query.TimeRange.GetFromAsTimeUTC(),
+				To:   query.TimeRange.GetToAsTimeUTC(),
+			},
+			QueryType: q.QueryType,
+			JSON:      modelJSON,
+		})
+	}
+
+	resp, err := a.handler.QueryData(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	tR := &tsdb.Response{
+		Results: make(map[string]*tsdb.QueryResult, len(resp.Responses)),
+	}
+
+	for refID, r := range resp.Responses {
+		qr := &tsdb.QueryResult{
+			RefId: refID,
+		}
+
+		for _, f := range r.Frames {
+			if f.RefID == "" {
+				f.RefID = refID
+			}
+		}
+
+		qr.Dataframes = tsdb.NewDecodedDataFrames(r.Frames)
+
+		if r.Error != nil {
+			qr.Error = r.Error
+		}
+
+		tR.Results[refID] = qr
+	}
+
+	return tR, nil
+}

pkg/plugins/backendplugin/client.go → pkg/plugins/backendplugin/grpcplugin/client.go

-package backendplugin
+package grpcplugin
 
 import (
 	"os/exec"
@@ -6,7 +6,9 @@ import (
 	datasourceV1 "github.com/grafana/grafana-plugin-model/go/datasource"
 	rendererV1 "github.com/grafana/grafana-plugin-model/go/renderer"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/grpcplugin"
+	sdkgrpcplugin "github.com/grafana/grafana-plugin-sdk-go/backend/grpcplugin"
 	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
 	"github.com/grafana/grafana/pkg/plugins/backendplugin/pluginextensionv2"
 	goplugin "github.com/hashicorp/go-plugin"
 )
@@ -26,8 +28,8 @@ var handshake = goplugin.HandshakeConfig{
 	ProtocolVersion: DefaultProtocolVersion,
 
 	// The magic cookie values should NEVER be changed.
-	MagicCookieKey:   grpcplugin.MagicCookieKey,
-	MagicCookieValue: grpcplugin.MagicCookieValue,
+	MagicCookieKey:   sdkgrpcplugin.MagicCookieKey,
+	MagicCookieValue: sdkgrpcplugin.MagicCookieValue,
 }
 
 func newClientConfig(executablePath string, env []string, logger log.Logger, versionedPlugins map[int]goplugin.PluginSet) *goplugin.ClientConfig {
@@ -72,18 +74,17 @@ func (pd PluginDescriptor) PluginID() string {
 // getV2PluginSet returns list of plugins supported on v2.
 func getV2PluginSet() goplugin.PluginSet {
 	return goplugin.PluginSet{
-		"diagnostics": &grpcplugin.DiagnosticsGRPCPlugin{},
-		"resource":    &grpcplugin.ResourceGRPCPlugin{},
-		"data":        &grpcplugin.DataGRPCPlugin{},
-		"transform":   &grpcplugin.TransformGRPCPlugin{},
+		"diagnostics": &sdkgrpcplugin.DiagnosticsGRPCPlugin{},
+		"resource":    &sdkgrpcplugin.ResourceGRPCPlugin{},
+		"data":        &sdkgrpcplugin.DataGRPCPlugin{},
+		"transform":   &sdkgrpcplugin.TransformGRPCPlugin{},
 		"renderer":    &pluginextensionv2.RendererGRPCPlugin{},
 	}
 }
 
-// NewBackendPluginDescriptor creates a new backend plugin descriptor
-// used for registering a backend datasource plugin.
-func NewBackendPluginDescriptor(pluginID, executablePath string, startFns PluginStartFuncs) PluginDescriptor {
-	return PluginDescriptor{
+// NewBackendPlugin creates a new backend plugin factory used for registering a backend plugin.
+func NewBackendPlugin(pluginID, executablePath string, startFns PluginStartFuncs) backendplugin.PluginFactoryFunc {
+	return New(PluginDescriptor{
 		pluginID:       pluginID,
 		executablePath: executablePath,
 		managed:        true,
@@ -91,16 +92,15 @@ func NewBackendPluginDescriptor(pluginID, executablePath string, startFns Plugin
 			DefaultProtocolVersion: {
 				pluginID: &datasourceV1.DatasourcePluginImpl{},
 			},
-			grpcplugin.ProtocolVersion: getV2PluginSet(),
+			sdkgrpcplugin.ProtocolVersion: getV2PluginSet(),
 		},
 		startFns: startFns,
-	}
+	})
 }
 
-// NewRendererPluginDescriptor creates a new renderer plugin descriptor
-// used for registering a backend renderer plugin.
-func NewRendererPluginDescriptor(pluginID, executablePath string, startFns PluginStartFuncs) PluginDescriptor {
-	return PluginDescriptor{
+// NewRendererPlugin creates a new renderer plugin factory used for registering a backend renderer plugin.
+func NewRendererPlugin(pluginID, executablePath string, startFns PluginStartFuncs) backendplugin.PluginFactoryFunc {
+	return New(PluginDescriptor{
 		pluginID:       pluginID,
 		executablePath: executablePath,
 		managed:        false,
@@ -108,38 +108,21 @@ func NewRendererPluginDescriptor(pluginID, executablePath string, startFns Plugi
 			DefaultProtocolVersion: {
 				pluginID: &rendererV1.RendererPluginImpl{},
 			},
-			grpcplugin.ProtocolVersion: getV2PluginSet(),
+			sdkgrpcplugin.ProtocolVersion: getV2PluginSet(),
 		},
 		startFns: startFns,
-	}
-}
-
-type DiagnosticsPlugin interface {
-	grpcplugin.DiagnosticsClient
-}
-
-type ResourcePlugin interface {
-	grpcplugin.ResourceClient
-}
-
-type DataPlugin interface {
-	grpcplugin.DataClient
-}
-
-type TransformPlugin interface {
-	grpcplugin.TransformClient
+	})
 }
 
-// LegacyClient client for communicating with a plugin using the old plugin protocol.
+// LegacyClient client for communicating with a plugin using the v1 plugin protocol.
 type LegacyClient struct {
 	DatasourcePlugin datasourceV1.DatasourcePlugin
 	RendererPlugin   rendererV1.RendererPlugin
 }
 
-// Client client for communicating with a plugin using the current plugin protocol.
+// Client client for communicating with a plugin using the current (v2) plugin protocol.
 type Client struct {
-	ResourcePlugin  ResourcePlugin
-	DataPlugin      DataPlugin
-	TransformPlugin TransformPlugin
+	DataPlugin      grpcplugin.DataClient
+	TransformPlugin grpcplugin.TransformClient
 	RendererPlugin  pluginextensionv2.RendererPlugin
 }

pkg/plugins/backendplugin/grpcplugin/client_v1.go

+package grpcplugin
+
+import (
+	"context"
+
+	datasourceV1 "github.com/grafana/grafana-plugin-model/go/datasource"
+	rendererV1 "github.com/grafana/grafana-plugin-model/go/renderer"
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/hashicorp/go-plugin"
+)
+
+type clientV1 struct {
+	logger log.Logger
+	datasourceV1.DatasourcePlugin
+	rendererV1.RendererPlugin
+}
+
+func newClientV1(descriptor PluginDescriptor, logger log.Logger, rpcClient plugin.ClientProtocol) (pluginClient, error) {
+	logger.Warn("Plugin uses a deprecated version of Grafana's backend plugin system which will be removed in a future release. " +
+		"Consider upgrading to a newer plugin version or reach out to the plugin repository/developer and request an upgrade.")
+
+	raw, err := rpcClient.Dispense(descriptor.pluginID)
+	if err != nil {
+		return nil, err
+	}
+
+	c := clientV1{
+		logger: logger,
+	}
+	if plugin, ok := raw.(datasourceV1.DatasourcePlugin); ok {
+		c.DatasourcePlugin = instrumentDatasourcePluginV1(plugin)
+	}
+
+	if plugin, ok := raw.(rendererV1.RendererPlugin); ok {
+		c.RendererPlugin = plugin
+	}
+
+	if descriptor.startFns.OnLegacyStart != nil {
+		legacyClient := &LegacyClient{
+			DatasourcePlugin: c.DatasourcePlugin,
+			RendererPlugin:   c.RendererPlugin,
+		}
+		if err := descriptor.startFns.OnLegacyStart(descriptor.pluginID, legacyClient, logger); err != nil {
+			return nil, err
+		}
+	}
+
+	return &c, nil
+}
+
+func (c *clientV1) CollectMetrics(ctx context.Context) (*backend.CollectMetricsResult, error) {
+	return nil, backendplugin.ErrMethodNotImplemented
+}
+
+func (c *clientV1) CheckHealth(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
+	return nil, backendplugin.ErrMethodNotImplemented
+}
+
+func (c *clientV1) CallResource(ctx context.Context, req *backend.CallResourceRequest, sender backend.CallResourceResponseSender) error {
+	return backendplugin.ErrMethodNotImplemented
+}
+
+type datasourceV1QueryFunc func(ctx context.Context, req *datasourceV1.DatasourceRequest) (*datasourceV1.DatasourceResponse, error)
+
+func (fn datasourceV1QueryFunc) Query(ctx context.Context, req *datasourceV1.DatasourceRequest) (*datasourceV1.DatasourceResponse, error) {
+	return fn(ctx, req)
+}
+
+func instrumentDatasourcePluginV1(plugin datasourceV1.DatasourcePlugin) datasourceV1.DatasourcePlugin {
+	if plugin == nil {
+		return nil
+	}
+
+	return datasourceV1QueryFunc(func(ctx context.Context, req *datasourceV1.DatasourceRequest) (*datasourceV1.DatasourceResponse, error) {
+		var resp *datasourceV1.DatasourceResponse
+		err := backendplugin.InstrumentQueryDataRequest(req.Datasource.Type, func() (innerErr error) {
+			resp, innerErr = plugin.Query(ctx, req)
+			return
+		})
+		return resp, err
+	})
+}

pkg/plugins/backendplugin/grpcplugin/client_v2.go

+package grpcplugin
+
+import (
+	"context"
+	"io"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/grpcplugin"
+	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin/pluginextensionv2"
+	"github.com/grafana/grafana/pkg/util/errutil"
+	"github.com/hashicorp/go-plugin"
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type clientV2 struct {
+	grpcplugin.DiagnosticsClient
+	grpcplugin.ResourceClient
+	grpcplugin.DataClient
+	grpcplugin.TransformClient
+	pluginextensionv2.RendererPlugin
+}
+
+func newClientV2(descriptor PluginDescriptor, logger log.Logger, rpcClient plugin.ClientProtocol) (pluginClient, error) {
+	rawDiagnostics, err := rpcClient.Dispense("diagnostics")
+	if err != nil {
+		return nil, err
+	}
+
+	rawResource, err := rpcClient.Dispense("resource")
+	if err != nil {
+		return nil, err
+	}
+
+	rawData, err := rpcClient.Dispense("data")
+	if err != nil {
+		return nil, err
+	}
+
+	rawTransform, err := rpcClient.Dispense("transform")
+	if err != nil {
+		return nil, err
+	}
+
+	rawRenderer, err := rpcClient.Dispense("renderer")
+	if err != nil {
+		return nil, err
+	}
+
+	c := clientV2{}
+	if rawDiagnostics != nil {
+		if plugin, ok := rawDiagnostics.(grpcplugin.DiagnosticsClient); ok {
+			c.DiagnosticsClient = plugin
+		}
+	}
+
+	if rawResource != nil {
+		if plugin, ok := rawResource.(grpcplugin.ResourceClient); ok {
+			c.ResourceClient = plugin
+		}
+	}
+
+	if rawData != nil {
+		if plugin, ok := rawData.(grpcplugin.DataClient); ok {
+			c.DataClient = instrumentDataClient(plugin)
+		}
+	}
+
+	if rawTransform != nil {
+		if plugin, ok := rawTransform.(grpcplugin.TransformClient); ok {
+			c.TransformClient = instrumentTransformPlugin(plugin)
+		}
+	}
+
+	if rawRenderer != nil {
+		if plugin, ok := rawRenderer.(pluginextensionv2.RendererPlugin); ok {
+			c.RendererPlugin = plugin
+		}
+	}
+
+	if descriptor.startFns.OnStart != nil {
+		client := &Client{
+			DataPlugin:      c.DataClient,
+			TransformPlugin: c.TransformClient,
+			RendererPlugin:  c.RendererPlugin,
+		}
+		if err := descriptor.startFns.OnStart(descriptor.pluginID, client, logger); err != nil {
+			return nil, err
+		}
+	}
+
+	return &c, nil
+}
+
+func (c *clientV2) CollectMetrics(ctx context.Context) (*backend.CollectMetricsResult, error) {
+	if c.DiagnosticsClient == nil {
+		return &backend.CollectMetricsResult{}, nil
+	}
+
+	protoResp, err := c.DiagnosticsClient.CollectMetrics(ctx, &pluginv2.CollectMetricsRequest{})
+	if err != nil {
+		if status.Code(err) == codes.Unimplemented {
+			return &backend.CollectMetricsResult{}, nil
+		}
+
+		return nil, err
+	}
+
+	return backend.FromProto().CollectMetricsResponse(protoResp), nil
+}
+
+func (c *clientV2) CheckHealth(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
+	if c.DiagnosticsClient == nil {
+		return nil, backendplugin.ErrMethodNotImplemented
+	}
+
+	protoContext := backend.ToProto().PluginContext(req.PluginContext)
+	protoResp, err := c.DiagnosticsClient.CheckHealth(ctx, &pluginv2.CheckHealthRequest{PluginContext: protoContext})
+
+	if err != nil {
+		if status.Code(err) == codes.Unimplemented {
+			return &backend.CheckHealthResult{
+				Status:  backend.HealthStatusUnknown,
+				Message: "Health check not implemented",
+			}, nil
+		}
+		return nil, err
+	}
+
+	return backend.FromProto().CheckHealthResponse(protoResp), nil
+}
+
+func (c *clientV2) CallResource(ctx context.Context, req *backend.CallResourceRequest, sender backend.CallResourceResponseSender) error {
+	if c.ResourceClient == nil {
+		return backendplugin.ErrMethodNotImplemented
+	}
+
+	protoReq := backend.ToProto().CallResourceRequest(req)
+	protoStream, err := c.ResourceClient.CallResource(ctx, protoReq)
+	if err != nil {
+		if status.Code(err) == codes.Unimplemented {
+			return backendplugin.ErrMethodNotImplemented
+		}
+
+		return errutil.Wrap("Failed to call resource", err)
+	}
+
+	for {
+		protoResp, err := protoStream.Recv()
+		if err != nil {
+			if status.Code(err) == codes.Unimplemented {
+				return backendplugin.ErrMethodNotImplemented
+			}
+
+			if err == io.EOF {
+				return nil
+			}
+
+			return errutil.Wrap("Failed to receive call resource response", err)
+		}
+
+		if err := sender.Send(backend.FromProto().CallResourceResponse(protoResp)); err != nil {
+			return err
+		}
+	}
+}
+
+type dataClientQueryDataFunc func(ctx context.Context, req *pluginv2.QueryDataRequest, opts ...grpc.CallOption) (*pluginv2.QueryDataResponse, error)
+
+func (fn dataClientQueryDataFunc) QueryData(ctx context.Context, req *pluginv2.QueryDataRequest, opts ...grpc.CallOption) (*pluginv2.QueryDataResponse, error) {
+	return fn(ctx, req, opts...)
+}
+
+func instrumentDataClient(plugin grpcplugin.DataClient) grpcplugin.DataClient {
+	if plugin == nil {
+		return nil
+	}
+
+	return dataClientQueryDataFunc(func(ctx context.Context, req *pluginv2.QueryDataRequest, opts ...grpc.CallOption) (*pluginv2.QueryDataResponse, error) {
+		var resp *pluginv2.QueryDataResponse
+		err := backendplugin.InstrumentQueryDataRequest(req.PluginContext.PluginId, func() (innerErr error) {
+			resp, innerErr = plugin.QueryData(ctx, req)
+			return
+		})
+		return resp, err
+	})
+}
+
+type transformPluginTransformDataFunc func(ctx context.Context, req *pluginv2.QueryDataRequest, callback grpcplugin.TransformDataCallBack) (*pluginv2.QueryDataResponse, error)
+
+func (fn transformPluginTransformDataFunc) TransformData(ctx context.Context, req *pluginv2.QueryDataRequest, callback grpcplugin.TransformDataCallBack) (*pluginv2.QueryDataResponse, error) {
+	return fn(ctx, req, callback)
+}
+
+func instrumentTransformPlugin(plugin grpcplugin.TransformClient) grpcplugin.TransformClient {
+	if plugin == nil {
+		return nil
+	}
+
+	return transformPluginTransformDataFunc(func(ctx context.Context, req *pluginv2.QueryDataRequest, callback grpcplugin.TransformDataCallBack) (*pluginv2.QueryDataResponse, error) {
+		var resp *pluginv2.QueryDataResponse
+		err := backendplugin.InstrumentTransformDataRequest(req.PluginContext.PluginId, func() (innerErr error) {
+			resp, innerErr = plugin.TransformData(ctx, req, callback)
+			return
+		})
+		return resp, err
+	})
+}

pkg/plugins/backendplugin/grpcplugin/grpc_plugin.go

+package grpcplugin
+
+import (
+	"context"
+	"errors"
+	"sync"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/hashicorp/go-plugin"
+)
+
+type pluginClient interface {
+	backend.CollectMetricsHandler
+	backend.CheckHealthHandler
+	backend.CallResourceHandler
+}
+
+type grpcPlugin struct {
+	descriptor    PluginDescriptor
+	clientFactory func() *plugin.Client
+	client        *plugin.Client
+	pluginClient  pluginClient
+	logger        log.Logger
+	mutex         sync.RWMutex
+}
+
+// New allocates and returns a new gRPC (external) backendplugin.Plugin.
+func New(descriptor PluginDescriptor) backendplugin.PluginFactoryFunc {
+	return backendplugin.PluginFactoryFunc(func(pluginID string, logger log.Logger, env []string) (backendplugin.Plugin, error) {
+		return &grpcPlugin{
+			descriptor: descriptor,
+			logger:     logger,
+			clientFactory: func() *plugin.Client {
+				return plugin.NewClient(newClientConfig(descriptor.executablePath, env, logger, descriptor.versionedPlugins))
+			},
+		}, nil
+	})
+}
+
+func (p *grpcPlugin) PluginID() string {
+	return p.descriptor.pluginID
+}
+
+func (p *grpcPlugin) Logger() log.Logger {
+	return p.logger
+}
+
+func (p *grpcPlugin) Start(ctx context.Context) error {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	p.client = p.clientFactory()
+	rpcClient, err := p.client.Client()
+	if err != nil {
+		return err
+	}
+
+	if p.client.NegotiatedVersion() > 1 {
+		p.pluginClient, err = newClientV2(p.descriptor, p.logger, rpcClient)
+		if err != nil {
+			return err
+		}
+	} else {
+		p.pluginClient, err = newClientV1(p.descriptor, p.logger, rpcClient)
+		if err != nil {
+			return err
+		}
+	}
+
+	if p.pluginClient == nil {
+		return errors.New("no compatible plugin implementation found")
+	}
+
+	return nil
+}
+
+func (p *grpcPlugin) Stop(ctx context.Context) error {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	if p.client != nil {
+		p.client.Kill()
+	}
+	return nil
+}
+
+func (p *grpcPlugin) IsManaged() bool {
+	return p.descriptor.managed
+}
+
+func (p *grpcPlugin) Exited() bool {
+	p.mutex.RLock()
+	defer p.mutex.RUnlock()
+	if p.client != nil {
+		return p.client.Exited()
+	}
+	return true
+}
+
+func (p *grpcPlugin) CollectMetrics(ctx context.Context) (*backend.CollectMetricsResult, error) {
+	p.mutex.RLock()
+	if p.client == nil || p.client.Exited() || p.pluginClient == nil {
+		p.mutex.RUnlock()
+		return nil, backendplugin.ErrPluginUnavailable
+	}
+	pluginClient := p.pluginClient
+	p.mutex.RUnlock()
+
+	return pluginClient.CollectMetrics(ctx)
+}
+
+func (p *grpcPlugin) CheckHealth(ctx context.Context, req *backend.CheckHealthRequest) (*backend.CheckHealthResult, error) {
+	p.mutex.RLock()
+	if p.client == nil || p.client.Exited() || p.pluginClient == nil {
+		p.mutex.RUnlock()
+		return nil, backendplugin.ErrPluginUnavailable
+	}
+	pluginClient := p.pluginClient
+	p.mutex.RUnlock()
+
+	return pluginClient.CheckHealth(ctx, req)
+}
+
+func (p *grpcPlugin) CallResource(ctx context.Context, req *backend.CallResourceRequest, sender backend.CallResourceResponseSender) error {
+	p.mutex.RLock()
+	if p.client == nil || p.client.Exited() || p.pluginClient == nil {
+		p.mutex.RUnlock()
+		return backendplugin.ErrPluginUnavailable
+	}
+	pluginClient := p.pluginClient
+	p.mutex.RUnlock()
+
+	return pluginClient.CallResource(ctx, req, sender)
+}

pkg/plugins/backendplugin/log_wrapper.go → pkg/plugins/backendplugin/grpcplugin/log_wrapper.go

-package backendplugin
+package grpcplugin
 
 import (
 	"io"

pkg/plugins/backendplugin/log_wrapper_test.go → pkg/plugins/backendplugin/grpcplugin/log_wrapper_test.go

-package backendplugin
+package grpcplugin
 
 import (
 	"fmt"

pkg/plugins/backendplugin/instrumentation.go

 package backendplugin
 
 import (
+	"context"
 	"time"
 
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/prometheus/client_golang/prometheus"
 )
 
@@ -28,8 +30,8 @@ func init() {
 	prometheus.MustRegister(pluginRequestCounter, pluginRequestDuration)
 }
 
-// InstrumentPluginRequest instruments success rate and latency of `fn`
-func InstrumentPluginRequest(pluginID string, endpoint string, fn func() error) error {
+// instrumentPluginRequest instruments success rate and latency of `fn`
+func instrumentPluginRequest(pluginID string, endpoint string, fn func() error) error {
 	status := "ok"
 
 	start := time.Now()
@@ -45,3 +47,41 @@ func InstrumentPluginRequest(pluginID string, endpoint string, fn func() error)
 
 	return err
 }
+
+func instrumentCollectMetrics(pluginID string, fn func() error) error {
+	return instrumentPluginRequest(pluginID, "collectMetrics", fn)
+}
+
+func instrumentCheckHealthRequest(pluginID string, fn func() error) error {
+	return instrumentPluginRequest(pluginID, "checkHealth", fn)
+}
+
+func instrumentCallResourceRequest(pluginID string, fn func() error) error {
+	return instrumentPluginRequest(pluginID, "callResource", fn)
+}
+
+// InstrumentQueryDataRequest instruments success rate and latency of query data request.
+func InstrumentQueryDataRequest(pluginID string, fn func() error) error {
+	return instrumentPluginRequest(pluginID, "queryData", fn)
+}
+
+// InstrumentTransformDataRequest instruments success rate and latency of transform data request.
+func InstrumentTransformDataRequest(pluginID string, fn func() error) error {
+	return instrumentPluginRequest(pluginID, "transformData", fn)
+}
+
+// InstrumentQueryDataHandler wraps a backend.QueryDataHandler with instrumentation of success rate and latency.
+func InstrumentQueryDataHandler(handler backend.QueryDataHandler) backend.QueryDataHandler {
+	if handler == nil {
+		return nil
+	}
+
+	return backend.QueryDataHandlerFunc(func(ctx context.Context, req *backend.QueryDataRequest) (*backend.QueryDataResponse, error) {
+		var resp *backend.QueryDataResponse
+		err := InstrumentQueryDataRequest(req.PluginContext.PluginID, func() (innerErr error) {
+			resp, innerErr = handler.QueryData(ctx, req)
+			return
+		})
+		return resp, err
+	})
+}

pkg/plugins/backendplugin/plugin.go

+package backendplugin
+
+import (
+	"context"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana/pkg/infra/log"
+)
+
+// Plugin backend plugin interface.
+type Plugin interface {
+	PluginID() string
+	Logger() log.Logger
+	Start(ctx context.Context) error
+	Stop(ctx context.Context) error
+	IsManaged() bool
+	Exited() bool
+	backend.CollectMetricsHandler
+	backend.CheckHealthHandler
+	backend.CallResourceHandler
+}
+
+// PluginFactoryFunc factory for creating a Plugin.
+type PluginFactoryFunc func(pluginID string, logger log.Logger, env []string) (Plugin, error)
+
+// CallResourceClientResponseStream is used for receiving resource call responses.
+type CallResourceClientResponseStream interface {
+	Recv() (*backend.CallResourceResponse, error)
+	Close() error
+}

pkg/plugins/backendplugin/resource_response_stream.go

+package backendplugin
+
+import (
+	"context"
+	"errors"
+	"io"
+
+	"github.com/grafana/grafana-plugin-sdk-go/backend"
+)
+
+func newCallResourceResponseStream(ctx context.Context) *callResourceResponseStream {
+	return &callResourceResponseStream{
+		ctx:    ctx,
+		stream: make(chan *backend.CallResourceResponse),
+	}
+}
+
+type callResourceResponseStream struct {
+	ctx    context.Context
+	stream chan *backend.CallResourceResponse
+	closed bool
+}
+
+func (s *callResourceResponseStream) Send(res *backend.CallResourceResponse) error {
+	if s.closed {
+		return errors.New("Cannot send to a closed stream")
+	}
+
+	select {
+	case <-s.ctx.Done():
+		return errors.New("cancelled")
+	case s.stream <- res:
+		return nil
+	}
+}
+
+func (s *callResourceResponseStream) Recv() (*backend.CallResourceResponse, error) {
+	select {
+	case <-s.ctx.Done():
+		return nil, s.ctx.Err()
+	case res, ok := <-s.stream:
+		if !ok {
+			return nil, io.EOF
+		}
+		return res, nil
+	}
+}
+
+func (s *callResourceResponseStream) Close() error {
+	if s.closed {
+		return errors.New("Cannot close a closed stream")
+	}
+
+	close(s.stream)
+	s.closed = true
+	return nil
+}

pkg/plugins/datasource/wrapper/datasource_plugin_wrapper_v2.go

@@ -4,22 +4,22 @@ import (
 	"context"
 	"fmt"
 
-	"github.com/grafana/grafana/pkg/components/simplejson"
-	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/grpcplugin"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
+	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/tsdb"
 )
 
-func NewDatasourcePluginWrapperV2(log log.Logger, pluginId, pluginType string, plugin backendplugin.DataPlugin) *DatasourcePluginWrapperV2 {
-	return &DatasourcePluginWrapperV2{DataPlugin: plugin, logger: log, pluginId: pluginId, pluginType: pluginType}
+func NewDatasourcePluginWrapperV2(log log.Logger, pluginId, pluginType string, client grpcplugin.DataClient) *DatasourcePluginWrapperV2 {
+	return &DatasourcePluginWrapperV2{DataClient: client, logger: log, pluginId: pluginId, pluginType: pluginType}
 }
 
 type DatasourcePluginWrapperV2 struct {
-	backendplugin.DataPlugin
+	grpcplugin.DataClient
 	logger     log.Logger
 	pluginId   string
 	pluginType string
@@ -79,14 +79,7 @@ func (tw *DatasourcePluginWrapperV2) Query(ctx context.Context, ds *models.DataS
 		})
 	}
 
-	var pbRes *pluginv2.QueryDataResponse
-	err = backendplugin.InstrumentPluginRequest(ds.Type, "dataquery", func() error {
-		var err error
-		pbRes, err = tw.DataPlugin.QueryData(ctx, pbQuery)
-
-		return err
-	})
-
+	pbRes, err := tw.DataClient.QueryData(ctx, pbQuery)
 	if err != nil {
 		return nil, err
 	}

pkg/plugins/datasource_plugin.go

@@ -4,14 +4,13 @@ import (
 	"encoding/json"
 	"path"
 
-	"github.com/grafana/grafana/pkg/plugins/backendplugin"
-
-	"github.com/grafana/grafana/pkg/util/errutil"
-
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin/grpcplugin"
 	"github.com/grafana/grafana/pkg/plugins/datasource/wrapper"
 	"github.com/grafana/grafana/pkg/tsdb"
+	"github.com/grafana/grafana/pkg/util/errutil"
 )
 
 // DataSourcePlugin contains all metadata about a datasource plugin
@@ -47,11 +46,11 @@ func (p *DataSourcePlugin) Load(decoder *json.Decoder, pluginDir string, backend
 	if p.Backend {
 		cmd := ComposePluginStartCommand(p.Executable)
 		fullpath := path.Join(p.PluginDir, cmd)
-		descriptor := backendplugin.NewBackendPluginDescriptor(p.Id, fullpath, backendplugin.PluginStartFuncs{
+		factory := grpcplugin.NewBackendPlugin(p.Id, fullpath, grpcplugin.PluginStartFuncs{
 			OnLegacyStart: p.onLegacyPluginStart,
 			OnStart:       p.onPluginStart,
 		})
-		if err := backendPluginManager.Register(descriptor); err != nil {
+		if err := backendPluginManager.Register(p.Id, factory); err != nil {
 			return errutil.Wrapf(err, "Failed to register backend plugin")
 		}
 	}
@@ -60,7 +59,7 @@ func (p *DataSourcePlugin) Load(decoder *json.Decoder, pluginDir string, backend
 	return nil
 }
 
-func (p *DataSourcePlugin) onLegacyPluginStart(pluginID string, client *backendplugin.LegacyClient, logger log.Logger) error {
+func (p *DataSourcePlugin) onLegacyPluginStart(pluginID string, client *grpcplugin.LegacyClient, logger log.Logger) error {
 	tsdb.RegisterTsdbQueryEndpoint(pluginID, func(dsInfo *models.DataSource) (tsdb.TsdbQueryEndpoint, error) {
 		return wrapper.NewDatasourcePluginWrapper(logger, client.DatasourcePlugin), nil
 	})
@@ -68,7 +67,7 @@ func (p *DataSourcePlugin) onLegacyPluginStart(pluginID string, client *backendp
 	return nil
 }
 
-func (p *DataSourcePlugin) onPluginStart(pluginID string, client *backendplugin.Client, logger log.Logger) error {
+func (p *DataSourcePlugin) onPluginStart(pluginID string, client *grpcplugin.Client, logger log.Logger) error {
 	if client.DataPlugin != nil {
 		tsdb.RegisterTsdbQueryEndpoint(pluginID, func(dsInfo *models.DataSource) (tsdb.TsdbQueryEndpoint, error) {
 			return wrapper.NewDatasourcePluginWrapperV2(logger, p.Id, p.Type, client.DataPlugin), nil

pkg/plugins/plugins_test.go

@@ -189,8 +189,8 @@ type fakeBackendPluginManager struct {
 	registeredPlugins []string
 }
 
-func (f *fakeBackendPluginManager) Register(descriptor backendplugin.PluginDescriptor) error {
-	f.registeredPlugins = append(f.registeredPlugins, descriptor.PluginID())
+func (f *fakeBackendPluginManager) Register(pluginID string, factory backendplugin.PluginFactoryFunc) error {
+	f.registeredPlugins = append(f.registeredPlugins, pluginID)
 	return nil
 }
 
@@ -198,11 +198,11 @@ func (f *fakeBackendPluginManager) StartPlugin(ctx context.Context, pluginID str
 	return nil
 }
 
-func (f *fakeBackendPluginManager) CollectMetrics(ctx context.Context, pluginID string) (*backendplugin.CollectMetricsResult, error) {
+func (f *fakeBackendPluginManager) CollectMetrics(ctx context.Context, pluginID string) (*backend.CollectMetricsResult, error) {
 	return nil, nil
 }
 
-func (f *fakeBackendPluginManager) CheckHealth(ctx context.Context, pCtx backend.PluginContext) (*backendplugin.CheckHealthResult, error) {
+func (f *fakeBackendPluginManager) CheckHealth(ctx context.Context, pCtx backend.PluginContext) (*backend.CheckHealthResult, error) {
 	return nil, nil
 }
 

pkg/plugins/renderer_plugin.go

@@ -8,6 +8,7 @@ import (
 	pluginModel "github.com/grafana/grafana-plugin-model/go/renderer"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin/grpcplugin"
 	"github.com/grafana/grafana/pkg/plugins/backendplugin/pluginextensionv2"
 	"github.com/grafana/grafana/pkg/util/errutil"
 )
@@ -34,11 +35,11 @@ func (r *RendererPlugin) Load(decoder *json.Decoder, pluginDir string, backendPl
 
 	cmd := ComposePluginStartCommand("plugin_start")
 	fullpath := path.Join(r.PluginDir, cmd)
-	descriptor := backendplugin.NewRendererPluginDescriptor(r.Id, fullpath, backendplugin.PluginStartFuncs{
+	factory := grpcplugin.NewRendererPlugin(r.Id, fullpath, grpcplugin.PluginStartFuncs{
 		OnLegacyStart: r.onLegacyPluginStart,
 		OnStart:       r.onPluginStart,
 	})
-	if err := backendPluginManager.Register(descriptor); err != nil {
+	if err := backendPluginManager.Register(r.Id, factory); err != nil {
 		return errutil.Wrapf(err, "Failed to register backend plugin")
 	}
 
@@ -54,12 +55,12 @@ func (r *RendererPlugin) Start(ctx context.Context) error {
 	return nil
 }
 
-func (r *RendererPlugin) onLegacyPluginStart(pluginID string, client *backendplugin.LegacyClient, logger log.Logger) error {
+func (r *RendererPlugin) onLegacyPluginStart(pluginID string, client *grpcplugin.LegacyClient, logger log.Logger) error {
 	r.GrpcPluginV1 = client.RendererPlugin
 	return nil
 }
 
-func (r *RendererPlugin) onPluginStart(pluginID string, client *backendplugin.Client, logger log.Logger) error {
+func (r *RendererPlugin) onPluginStart(pluginID string, client *grpcplugin.Client, logger log.Logger) error {
 	r.GrpcPluginV2 = client.RendererPlugin
 	return nil
 }

pkg/plugins/transform_plugin.go

@@ -7,12 +7,14 @@ import (
 	"path"
 	"strconv"
 
+	sdkgrpcplugin "github.com/grafana/grafana-plugin-sdk-go/backend/grpcplugin"
 	"github.com/grafana/grafana-plugin-sdk-go/genproto/pluginv2"
 	"github.com/grafana/grafana/pkg/bus"
 	"github.com/grafana/grafana/pkg/components/simplejson"
 	"github.com/grafana/grafana/pkg/infra/log"
 	"github.com/grafana/grafana/pkg/models"
 	"github.com/grafana/grafana/pkg/plugins/backendplugin"
+	"github.com/grafana/grafana/pkg/plugins/backendplugin/grpcplugin"
 	"github.com/grafana/grafana/pkg/plugins/datasource/wrapper"
 	"github.com/grafana/grafana/pkg/tsdb"
 	"github.com/grafana/grafana/pkg/util/errutil"
@@ -37,10 +39,10 @@ func (p *TransformPlugin) Load(decoder *json.Decoder, pluginDir string, backendP
 
 	cmd := ComposePluginStartCommand(p.Executable)
 	fullpath := path.Join(p.PluginDir, cmd)
-	descriptor := backendplugin.NewBackendPluginDescriptor(p.Id, fullpath, backendplugin.PluginStartFuncs{
+	factory := grpcplugin.NewBackendPlugin(p.Id, fullpath, grpcplugin.PluginStartFuncs{
 		OnStart: p.onPluginStart,
 	})
-	if err := backendPluginManager.Register(descriptor); err != nil {
+	if err := backendPluginManager.Register(p.Id, factory); err != nil {
 		return errutil.Wrapf(err, "Failed to register backend plugin")
 	}
 
@@ -49,7 +51,7 @@ func (p *TransformPlugin) Load(decoder *json.Decoder, pluginDir string, backendP
 	return nil
 }
 
-func (p *TransformPlugin) onPluginStart(pluginID string, client *backendplugin.Client, logger log.Logger) error {
+func (p *TransformPlugin) onPluginStart(pluginID string, client *grpcplugin.Client, logger log.Logger) error {
 	p.TransformWrapper = NewTransformWrapper(logger, client.TransformPlugin)
 
 	if client.DataPlugin != nil {
@@ -65,12 +67,12 @@ func (p *TransformPlugin) onPluginStart(pluginID string, client *backendplugin.C
 // Wrapper Code
 // ...
 
-func NewTransformWrapper(log log.Logger, plugin backendplugin.TransformPlugin) *TransformWrapper {
+func NewTransformWrapper(log log.Logger, plugin sdkgrpcplugin.TransformClient) *TransformWrapper {
 	return &TransformWrapper{plugin, log, &transformCallback{log}}
 }
 
 type TransformWrapper struct {
-	backendplugin.TransformPlugin
+	sdkgrpcplugin.TransformClient
 	logger   log.Logger
 	callback *transformCallback
 }
@@ -100,7 +102,7 @@ func (tw *TransformWrapper) Transform(ctx context.Context, query *tsdb.TsdbQuery
 			},
 		})
 	}
-	pbRes, err := tw.TransformPlugin.TransformData(ctx, pbQuery, tw.callback)
+	pbRes, err := tw.TransformClient.TransformData(ctx, pbQuery, tw.callback)
 	if err != nil {
 		return nil, err
 	}

pkg/setting/setting.go

@@ -228,6 +228,16 @@ type Cfg struct {
 	AppSubUrl        string
 	ServeFromSubPath bool
 
+	// build
+	BuildVersion string
+	BuildCommit  string
+	BuildBranch  string
+	BuildStamp   int64
+	IsEnterprise bool
+
+	// packaging
+	Packaging string
+
 	// Paths
 	ProvisioningPath   string
 	DataPath           string
@@ -607,6 +617,13 @@ func (cfg *Cfg) Load(args *CommandLineArgs) error {
 	// Temporary keep global, to make refactor in steps
 	Raw = cfg.Raw
 
+	cfg.BuildVersion = BuildVersion
+	cfg.BuildCommit = BuildCommit
+	cfg.BuildStamp = BuildStamp
+	cfg.BuildBranch = BuildBranch
+	cfg.IsEnterprise = IsEnterprise
+	cfg.Packaging = Packaging
+
 	ApplicationName = APP_NAME
 
 	Env, err = valueAsString(iniFile.Section(""), "app_mode", "development")