Plugins: Refactor Plugin Management (#40477)

* add core plugin flow * add instrumentation * move func * remove cruft * support external backend plugins * refactor + clean up * remove comments * refactor loader * simplify core plugin path arg * cleanup loggers * move signature validator to plugins package * fix sig packaging * cleanup plugin model * remove unnecessary plugin field * add start+stop for pm * fix failures * add decommissioned state * export fields just to get things flowing * fix comments * set static routes * make image loading idempotent * merge with backend plugin manager * re-use funcs * reorder imports + remove unnecessary interface * add some TODOs + remove unused func * remove unused instrumentation func * simplify client usage * remove import alias * re-use backendplugin.Plugin interface * re order funcs * improve var name * fix log statements * refactor data model * add logic for dupe check during loading * cleanup state setting * refactor loader * cleanup manager interface * add rendering flow * refactor loading + init * add renderer support * fix renderer plugin * reformat imports * track errors * fix plugin signature inheritance * name param in interface * update func comment * fix func arg name * introduce class concept * remove func * fix external plugin check * apply changes from pm-experiment * fix core plugins * fix imports * rename interface * comment API interface * add support for testdata plugin * enable alerting + use correct core plugin contracts * slim manager API * fix param name * fix filter * support static routes * fix rendering * tidy rendering * get tests compiling * fix install+uninstall * start finder test * add finder test coverage * start loader tests * add test for core plugins * load core + bundled test * add test for nested plugin loading * add test files * clean interface + fix registering some core plugins * refactoring * reformat and create sub packages * simplify core plugin init * fix ctx cancel scenario * migrate initializer * remove Init() funcs * add test starter * new logger * flesh out initializer tests * refactoring * remove unused svc * refactor rendering flow * fixup loader tests * add enabled helper func * fix logger name * fix data fetchers * fix case where plugin dir doesn't exist * improve coverage + move dupe checking to loader * remove noisy debug logs * register core plugins automagically * add support for renderer in catalog * make private func + fix req validation * use interface * re-add check for renderer in catalog * tidy up from moving to auto reg core plugins * core plugin registrar * guards * copy over core plugins for test infra * all tests green * renames * propagate new interfaces * kill old manager * get compiling * tidy up * update naming * refactor manager test + cleanup * add more cases to finder test * migrate validator to field * more coverage * refactor dupe checking * add test for plugin class * add coverage for initializer * split out rendering * move * fixup tests * fix uss test * fix frontend settings * fix grafanads test * add check when checking sig errors * fix enabled map * fixup * allow manual setup of CM * rename to cloud-monitoring * remove TODO * add installer interface for testing * loader interface returns * tests passing * refactor + add more coverage * support 'stackdriver' * fix frontend settings loading * improve naming based on package name * small tidy * refactor test * fix renderer start * make cloud-monitoring plugin ID clearer * add plugin update test * add integration tests * don't break all if sig can't be calculated * add root URL check test * add more signature verification tests * update DTO name * update enabled plugins comment * update comments * fix linter * revert fe naming change * fix errors endpoint * reset error code field name * re-order test to help verify * assert -> require * pm check * add missing entry + re-order * re-check * dump icon log * verify manager contents first * reformat * apply PR feedback * apply style changes * fix one vs all loading err * improve log output * only start when no signature error * move log * rework plugin update check * fix test * fix multi loading from cfg.PluginSettings * improve log output #2 * add error abstraction to capture errors without registering a plugin * add debug log * add unsigned warning * e2e test attempt * fix logger * set home path * prevent panic * alternate * ugh.. fix home path * return renderer even if not started * make renderer plugin managed * add fallback renderer icon, update renderer badge + prevent changes when renderer is installed * fix icon loading * rollback renderer changes * use correct field * remove unneccessary block * remove newline * remove unused func * fix bundled plugins base + module fields * remove unused field since refactor * add authorizer abstraction * loader only returns plugins expected to run * fix multi log output
2025-02-25 18:55:37 -06:00 · 2021-11-01 09:53:33 +00:00
parent f4282571c7
commit b80fbe03f0
136 changed files with 7140 additions and 4486 deletions
--- a/pkg/api/pluginproxy/ds_auth_provider.go
+++ b/pkg/api/pluginproxy/ds_auth_provider.go
@@ -21,7 +21,7 @@ type DSInfo struct {
 }

 // ApplyRoute should use the plugin route data to set auth headers and custom headers.
-func ApplyRoute(ctx context.Context, req *http.Request, proxyPath string, route *plugins.AppPluginRoute,
+func ApplyRoute(ctx context.Context, req *http.Request, proxyPath string, route *plugins.Route,
 	ds DSInfo, cfg *setting.Cfg) {
 	proxyPath = strings.TrimPrefix(proxyPath, route.Path)

@@ -76,7 +76,7 @@ func ApplyRoute(ctx context.Context, req *http.Request, proxyPath string, route
 	}
 }

-func getTokenProvider(ctx context.Context, cfg *setting.Cfg, ds DSInfo, pluginRoute *plugins.AppPluginRoute,
+func getTokenProvider(ctx context.Context, cfg *setting.Cfg, ds DSInfo, pluginRoute *plugins.Route,
 	data templateData) (accessTokenProvider, error) {
 	authType := pluginRoute.AuthType

@@ -133,7 +133,7 @@ func getTokenProvider(ctx context.Context, cfg *setting.Cfg, ds DSInfo, pluginRo
 	}
 }

-func interpolateAuthParams(tokenAuth *plugins.JwtTokenAuth, data templateData) (*plugins.JwtTokenAuth, error) {
+func interpolateAuthParams(tokenAuth *plugins.JWTTokenAuth, data templateData) (*plugins.JWTTokenAuth, error) {
 	if tokenAuth == nil {
 		// Nothing to interpolate
 		return nil, nil
@@ -153,7 +153,7 @@ func interpolateAuthParams(tokenAuth *plugins.JwtTokenAuth, data templateData) (
 		interpolatedParams[key] = interpolatedParam
 	}

-	return &plugins.JwtTokenAuth{
+	return &plugins.JWTTokenAuth{
 		Url:    interpolatedUrl,
 		Scopes: tokenAuth.Scopes,
 		Params: interpolatedParams,
--- a/pkg/api/pluginproxy/ds_auth_provider_test.go
+++ b/pkg/api/pluginproxy/ds_auth_provider_test.go
@@ -9,7 +9,7 @@ import (
 )

 func TestApplyRoute_interpolateAuthParams(t *testing.T) {
-	tokenAuth := &plugins.JwtTokenAuth{
+	tokenAuth := &plugins.JWTTokenAuth{
 		Url: "https://login.server.com/{{.JsonData.tenantId}}/oauth2/token",
 		Scopes: []string{
 			"https://www.testapi.com/auth/Read.All",
@@ -38,7 +38,7 @@ func TestApplyRoute_interpolateAuthParams(t *testing.T) {
 		SecureJsonData: map[string]string{},
 	}

-	t.Run("should interpolate JwtTokenAuth struct using given JsonData", func(t *testing.T) {
+	t.Run("should interpolate JWTTokenAuth struct using given JsonData", func(t *testing.T) {
 		interpolated, err := interpolateAuthParams(tokenAuth, validData)
 		require.NoError(t, err)
 		require.NotNil(t, interpolated)
@@ -54,7 +54,7 @@ func TestApplyRoute_interpolateAuthParams(t *testing.T) {
 		assert.Equal(t, "testkey", interpolated.Params["private_key"])
 	})

-	t.Run("should return Nil if given JwtTokenAuth is Nil", func(t *testing.T) {
+	t.Run("should return Nil if given JWTTokenAuth is Nil", func(t *testing.T) {
 		interpolated, err := interpolateAuthParams(nil, validData)
 		require.NoError(t, err)
 		require.Nil(t, interpolated)
--- a/pkg/api/pluginproxy/ds_proxy.go
+++ b/pkg/api/pluginproxy/ds_proxy.go
@@ -36,8 +36,8 @@ type DataSourceProxy struct {
 	ctx                *models.ReqContext
 	targetUrl          *url.URL
 	proxyPath          string
-	route              *plugins.AppPluginRoute
-	plugin             *plugins.DataSourcePlugin
+	matchedRoute       *plugins.Route
+	pluginRoutes       []*plugins.Route
 	cfg                *setting.Cfg
 	clientProvider     httpclient.Provider
 	oAuthTokenService  oauthtoken.OAuthTokenService
@@ -73,7 +73,7 @@ func (lw *logWrapper) Write(p []byte) (n int, err error) {
 }

 // NewDataSourceProxy creates a new Datasource proxy
-func NewDataSourceProxy(ds *models.DataSource, plugin *plugins.DataSourcePlugin, ctx *models.ReqContext,
+func NewDataSourceProxy(ds *models.DataSource, pluginRoutes []*plugins.Route, ctx *models.ReqContext,
 	proxyPath string, cfg *setting.Cfg, clientProvider httpclient.Provider,
 	oAuthTokenService oauthtoken.OAuthTokenService, dsService *datasources.Service) (*DataSourceProxy, error) {
 	targetURL, err := datasource.ValidateURL(ds.Type, ds.Url)
@@ -83,7 +83,7 @@ func NewDataSourceProxy(ds *models.DataSource, plugin *plugins.DataSourcePlugin,

 	return &DataSourceProxy{
 		ds:                 ds,
-		plugin:             plugin,
+		pluginRoutes:       pluginRoutes,
 		ctx:                ctx,
 		proxyPath:          proxyPath,
 		targetUrl:          targetURL,
@@ -257,8 +257,8 @@ func (proxy *DataSourceProxy) director(req *http.Request) {
 		return
 	}

-	if proxy.route != nil {
-		ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.route, DSInfo{
+	if proxy.matchedRoute != nil {
+		ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.matchedRoute, DSInfo{
 			ID:                      proxy.ds.Id,
 			Updated:                 proxy.ds.Updated,
 			JSONData:                jsonData,
@@ -291,27 +291,25 @@ func (proxy *DataSourceProxy) validateRequest() error {
 	}

 	// found route if there are any
-	if len(proxy.plugin.Routes) > 0 {
-		for _, route := range proxy.plugin.Routes {
-			// method match
-			if route.Method != "" && route.Method != "*" && route.Method != proxy.ctx.Req.Method {
-				continue
-			}
-
-			// route match
-			if !strings.HasPrefix(proxy.proxyPath, route.Path) {
-				continue
-			}
-
-			if route.ReqRole.IsValid() {
-				if !proxy.ctx.HasUserRole(route.ReqRole) {
-					return errors.New("plugin proxy route access denied")
-				}
-			}
-
-			proxy.route = route
-			return nil
+	for _, route := range proxy.pluginRoutes {
+		// method match
+		if route.Method != "" && route.Method != "*" && route.Method != proxy.ctx.Req.Method {
+			continue
 		}
+
+		// route match
+		if !strings.HasPrefix(proxy.proxyPath, route.Path) {
+			continue
+		}
+
+		if route.ReqRole.IsValid() {
+			if !proxy.ctx.HasUserRole(route.ReqRole) {
+				return errors.New("plugin proxy route access denied")
+			}
+		}
+
+		proxy.matchedRoute = route
+		return nil
 	}

 	// Trailing validation below this point for routes that were not matched
--- a/pkg/api/pluginproxy/ds_proxy_test.go
+++ b/pkg/api/pluginproxy/ds_proxy_test.go
@@ -32,51 +32,49 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	httpClientProvider := httpclient.NewProvider()

 	t.Run("Plugin with routes", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{
-			Routes: []*plugins.AppPluginRoute{
-				{
-					Path:    "api/v4/",
-					URL:     "https://www.google.com",
-					ReqRole: models.ROLE_EDITOR,
-					Headers: []plugins.AppPluginRouteHeader{
-						{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
-					},
+		routes := []*plugins.Route{
+			{
+				Path:    "api/v4/",
+				URL:     "https://www.google.com",
+				ReqRole: models.ROLE_EDITOR,
+				Headers: []plugins.Header{
+					{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
 				},
-				{
-					Path:    "api/admin",
-					URL:     "https://www.google.com",
-					ReqRole: models.ROLE_ADMIN,
-					Headers: []plugins.AppPluginRouteHeader{
-						{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
-					},
+			},
+			{
+				Path:    "api/admin",
+				URL:     "https://www.google.com",
+				ReqRole: models.ROLE_ADMIN,
+				Headers: []plugins.Header{
+					{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
 				},
-				{
-					Path: "api/anon",
-					URL:  "https://www.google.com",
-					Headers: []plugins.AppPluginRouteHeader{
-						{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
-					},
+			},
+			{
+				Path: "api/anon",
+				URL:  "https://www.google.com",
+				Headers: []plugins.Header{
+					{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
 				},
-				{
-					Path: "api/common",
-					URL:  "{{.JsonData.dynamicUrl}}",
-					URLParams: []plugins.AppPluginRouteURLParam{
-						{Name: "{{.JsonData.queryParam}}", Content: "{{.SecureJsonData.key}}"},
-					},
-					Headers: []plugins.AppPluginRouteHeader{
-						{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
-					},
+			},
+			{
+				Path: "api/common",
+				URL:  "{{.JsonData.dynamicUrl}}",
+				URLParams: []plugins.URLParam{
+					{Name: "{{.JsonData.queryParam}}", Content: "{{.SecureJsonData.key}}"},
 				},
-				{
-					Path:    "api/restricted",
-					ReqRole: models.ROLE_ADMIN,
-				},
-				{
-					Path: "api/body",
-					URL:  "http://www.test.com",
-					Body: []byte(`{ "url": "{{.JsonData.dynamicUrl}}", "secret": "{{.SecureJsonData.key}}"	}`),
+				Headers: []plugins.Header{
+					{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
 				},
 			},
+			{
+				Path:    "api/restricted",
+				ReqRole: models.ROLE_ADMIN,
+			},
+			{
+				Path: "api/body",
+				URL:  "http://www.test.com",
+				Body: []byte(`{ "url": "{{.JsonData.dynamicUrl}}", "secret": "{{.SecureJsonData.key}}"	}`),
+			},
 		}

 		origSecretKey := setting.SecretKey
@@ -125,10 +123,11 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		t.Run("When matching route path", func(t *testing.T) {
 			ctx, req := setUp()
 			dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-			proxy, err := NewDataSourceProxy(ds, plugin, ctx, "api/v4/some/method", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+			proxy, err := NewDataSourceProxy(ds, routes, ctx, "api/v4/some/method", cfg, httpClientProvider,
+				&oauthtoken.Service{}, dsService)
 			require.NoError(t, err)
-			proxy.route = plugin.Routes[0]
-			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.route, dsInfo, cfg)
+			proxy.matchedRoute = routes[0]
+			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.matchedRoute, dsInfo, cfg)

 			assert.Equal(t, "https://www.google.com/some/method", req.URL.String())
 			assert.Equal(t, "my secret 123", req.Header.Get("x-header"))
@@ -137,10 +136,10 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		t.Run("When matching route path and has dynamic url", func(t *testing.T) {
 			ctx, req := setUp()
 			dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-			proxy, err := NewDataSourceProxy(ds, plugin, ctx, "api/common/some/method", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+			proxy, err := NewDataSourceProxy(ds, routes, ctx, "api/common/some/method", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 			require.NoError(t, err)
-			proxy.route = plugin.Routes[3]
-			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.route, dsInfo, cfg)
+			proxy.matchedRoute = routes[3]
+			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.matchedRoute, dsInfo, cfg)

 			assert.Equal(t, "https://dynamic.grafana.com/some/method?apiKey=123", req.URL.String())
 			assert.Equal(t, "my secret 123", req.Header.Get("x-header"))
@@ -149,10 +148,10 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		t.Run("When matching route path with no url", func(t *testing.T) {
 			ctx, req := setUp()
 			dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-			proxy, err := NewDataSourceProxy(ds, plugin, ctx, "", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+			proxy, err := NewDataSourceProxy(ds, routes, ctx, "", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 			require.NoError(t, err)
-			proxy.route = plugin.Routes[4]
-			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.route, dsInfo, cfg)
+			proxy.matchedRoute = routes[4]
+			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.matchedRoute, dsInfo, cfg)

 			assert.Equal(t, "http://localhost/asd", req.URL.String())
 		})
@@ -160,10 +159,10 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		t.Run("When matching route path and has dynamic body", func(t *testing.T) {
 			ctx, req := setUp()
 			dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-			proxy, err := NewDataSourceProxy(ds, plugin, ctx, "api/body", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+			proxy, err := NewDataSourceProxy(ds, routes, ctx, "api/body", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 			require.NoError(t, err)
-			proxy.route = plugin.Routes[5]
-			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.route, dsInfo, cfg)
+			proxy.matchedRoute = routes[5]
+			ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, proxy.matchedRoute, dsInfo, cfg)

 			content, err := ioutil.ReadAll(req.Body)
 			require.NoError(t, err)
@@ -174,7 +173,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 			t.Run("plugin route with valid role", func(t *testing.T) {
 				ctx, _ := setUp()
 				dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-				proxy, err := NewDataSourceProxy(ds, plugin, ctx, "api/v4/some/method", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+				proxy, err := NewDataSourceProxy(ds, routes, ctx, "api/v4/some/method", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 				require.NoError(t, err)
 				err = proxy.validateRequest()
 				require.NoError(t, err)
@@ -183,7 +182,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 			t.Run("plugin route with admin role and user is editor", func(t *testing.T) {
 				ctx, _ := setUp()
 				dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-				proxy, err := NewDataSourceProxy(ds, plugin, ctx, "api/admin", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+				proxy, err := NewDataSourceProxy(ds, routes, ctx, "api/admin", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 				require.NoError(t, err)
 				err = proxy.validateRequest()
 				require.Error(t, err)
@@ -193,7 +192,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 				ctx, _ := setUp()
 				ctx.SignedInUser.OrgRole = models.ROLE_ADMIN
 				dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-				proxy, err := NewDataSourceProxy(ds, plugin, ctx, "api/admin", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+				proxy, err := NewDataSourceProxy(ds, routes, ctx, "api/admin", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 				require.NoError(t, err)
 				err = proxy.validateRequest()
 				require.NoError(t, err)
@@ -202,32 +201,30 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	})

 	t.Run("Plugin with multiple routes for token auth", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{
-			Routes: []*plugins.AppPluginRoute{
-				{
-					Path: "pathwithtoken1",
-					URL:  "https://api.nr1.io/some/path",
-					TokenAuth: &plugins.JwtTokenAuth{
-						Url: "https://login.server.com/{{.JsonData.tenantId}}/oauth2/token",
-						Params: map[string]string{
-							"grant_type":    "client_credentials",
-							"client_id":     "{{.JsonData.clientId}}",
-							"client_secret": "{{.SecureJsonData.clientSecret}}",
-							"resource":      "https://api.nr1.io",
-						},
+		routes := []*plugins.Route{
+			{
+				Path: "pathwithtoken1",
+				URL:  "https://api.nr1.io/some/path",
+				TokenAuth: &plugins.JWTTokenAuth{
+					Url: "https://login.server.com/{{.JsonData.tenantId}}/oauth2/token",
+					Params: map[string]string{
+						"grant_type":    "client_credentials",
+						"client_id":     "{{.JsonData.clientId}}",
+						"client_secret": "{{.SecureJsonData.clientSecret}}",
+						"resource":      "https://api.nr1.io",
 					},
 				},
-				{
-					Path: "pathwithtoken2",
-					URL:  "https://api.nr2.io/some/path",
-					TokenAuth: &plugins.JwtTokenAuth{
-						Url: "https://login.server.com/{{.JsonData.tenantId}}/oauth2/token",
-						Params: map[string]string{
-							"grant_type":    "client_credentials",
-							"client_id":     "{{.JsonData.clientId}}",
-							"client_secret": "{{.SecureJsonData.clientSecret}}",
-							"resource":      "https://api.nr2.io",
-						},
+			},
+			{
+				Path: "pathwithtoken2",
+				URL:  "https://api.nr2.io/some/path",
+				TokenAuth: &plugins.JWTTokenAuth{
+					Url: "https://login.server.com/{{.JsonData.tenantId}}/oauth2/token",
+					Params: map[string]string{
+						"grant_type":    "client_credentials",
+						"client_id":     "{{.JsonData.clientId}}",
+						"client_secret": "{{.SecureJsonData.clientSecret}}",
+						"resource":      "https://api.nr2.io",
 					},
 				},
 			},
@@ -285,9 +282,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 				}

 				dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-				proxy, err := NewDataSourceProxy(ds, plugin, ctx, "pathwithtoken1", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+				proxy, err := NewDataSourceProxy(ds, routes, ctx, "pathwithtoken1", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 				require.NoError(t, err)
-				ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, plugin.Routes[0], dsInfo, cfg)
+				ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, routes[0], dsInfo, cfg)

 				authorizationHeaderCall1 = req.Header.Get("Authorization")
 				assert.Equal(t, "https://api.nr1.io/some/path", req.URL.String())
@@ -301,9 +298,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 					require.NoError(t, err)
 					client = newFakeHTTPClient(t, json2)
 					dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-					proxy, err := NewDataSourceProxy(ds, plugin, ctx, "pathwithtoken2", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+					proxy, err := NewDataSourceProxy(ds, routes, ctx, "pathwithtoken2", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 					require.NoError(t, err)
-					ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, plugin.Routes[1], dsInfo, cfg)
+					ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, routes[1], dsInfo, cfg)

 					authorizationHeaderCall2 = req.Header.Get("Authorization")

@@ -318,9 +315,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {

 						client = newFakeHTTPClient(t, []byte{})
 						dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-						proxy, err := NewDataSourceProxy(ds, plugin, ctx, "pathwithtoken1", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
+						proxy, err := NewDataSourceProxy(ds, routes, ctx, "pathwithtoken1", cfg, httpClientProvider, &oauthtoken.Service{}, dsService)
 						require.NoError(t, err)
-						ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, plugin.Routes[0], dsInfo, cfg)
+						ApplyRoute(proxy.ctx.Req.Context(), req, proxy.proxyPath, routes[0], dsInfo, cfg)

 						authorizationHeaderCall3 := req.Header.Get("Authorization")
 						assert.Equal(t, "https://api.nr1.io/some/path", req.URL.String())
@@ -334,12 +331,12 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	})

 	t.Run("When proxying graphite", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{}
+		var routes []*plugins.Route
 		ds := &models.DataSource{Url: "htttp://graphite:8080", Type: models.DS_GRAPHITE}
 		ctx := &models.ReqContext{}

 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/render", &setting.Cfg{BuildVersion: "5.3.0"}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/render", &setting.Cfg{BuildVersion: "5.3.0"}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)
 		req, err := http.NewRequest(http.MethodGet, "http://grafana.com/sub", nil)
 		require.NoError(t, err)
@@ -353,8 +350,6 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	})

 	t.Run("When proxying InfluxDB", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{}
-
 		ds := &models.DataSource{
 			Type:     models.DS_INFLUXDB_08,
 			Url:      "http://influxdb:8083",
@@ -364,8 +359,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		}

 		ctx := &models.ReqContext{}
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		req, err := http.NewRequest(http.MethodGet, "http://grafana.com/sub", nil)
@@ -376,8 +372,6 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	})

 	t.Run("When proxying a data source with no keepCookies specified", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{}
-
 		json, err := simplejson.NewJson([]byte(`{"keepCookies": []}`))
 		require.NoError(t, err)

@@ -388,8 +382,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		}

 		ctx := &models.ReqContext{}
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		requestURL, err := url.Parse("http://grafana.com/sub")
@@ -404,8 +399,6 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	})

 	t.Run("When proxying a data source with keep cookies specified", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{}
-
 		json, err := simplejson.NewJson([]byte(`{"keepCookies": ["JSESSION_ID"]}`))
 		require.NoError(t, err)

@@ -416,8 +409,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 		}

 		ctx := &models.ReqContext{}
+		var pluginRoutes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, pluginRoutes, ctx, "", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		requestURL, err := url.Parse("http://grafana.com/sub")
@@ -432,14 +426,14 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 	})

 	t.Run("When proxying a custom datasource", func(t *testing.T) {
-		plugin := &plugins.DataSourcePlugin{}
 		ds := &models.DataSource{
 			Type: "custom-datasource",
 			Url:  "http://host/root/",
 		}
 		ctx := &models.ReqContext{}
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/path/to/folder/", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/path/to/folder/", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)
 		req, err := http.NewRequest(http.MethodGet, "http://grafana.com/sub", nil)
 		req.Header.Set("Origin", "grafana.com")
@@ -470,7 +464,6 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 			return nil
 		})

-		plugin := &plugins.DataSourcePlugin{}
 		ds := &models.DataSource{
 			Type: "custom-datasource",
 			Url:  "http://host/root/",
@@ -494,8 +487,9 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
 			},
 			oAuthEnabled: true,
 		}
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/path/to/folder/", &setting.Cfg{}, httpClientProvider, &mockAuthToken, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/path/to/folder/", &setting.Cfg{}, httpClientProvider, &mockAuthToken, dsService)
 		require.NoError(t, err)
 		req, err = http.NewRequest(http.MethodGet, "http://grafana.com/sub", nil)
 		require.NoError(t, err)
@@ -570,8 +564,6 @@ func TestDataSourceProxy_requestHandling(t *testing.T) {
 	httpClientProvider := httpclient.NewProvider()
 	var writeErr error

-	plugin := &plugins.DataSourcePlugin{}
-
 	type setUpCfg struct {
 		headers map[string]string
 		writeCb func(w http.ResponseWriter, r *http.Request)
@@ -621,8 +613,10 @@ func TestDataSourceProxy_requestHandling(t *testing.T) {

 	t.Run("When response header Set-Cookie is not set should remove proxied Set-Cookie header", func(t *testing.T) {
 		ctx, ds := setUp(t)
+
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/render", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/render", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		proxy.HandleRequest()
@@ -637,8 +631,9 @@ func TestDataSourceProxy_requestHandling(t *testing.T) {
 				"Set-Cookie": "important_cookie=important_value",
 			},
 		})
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/render", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/render", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		proxy.HandleRequest()
@@ -657,8 +652,9 @@ func TestDataSourceProxy_requestHandling(t *testing.T) {
 				t.Log("Wrote 401 response")
 			},
 		})
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/render", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/render", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		proxy.HandleRequest()
@@ -680,8 +676,9 @@ func TestDataSourceProxy_requestHandling(t *testing.T) {
 		})

 		ctx.Req = httptest.NewRequest("GET", "/api/datasources/proxy/1/path/%2Ftest%2Ftest%2F?query=%2Ftest%2Ftest%2F", nil)
+		var routes []*plugins.Route
 		dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-		proxy, err := NewDataSourceProxy(ds, plugin, ctx, "/path/%2Ftest%2Ftest%2F", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
+		proxy, err := NewDataSourceProxy(ds, routes, ctx, "/path/%2Ftest%2Ftest%2F", &setting.Cfg{}, httpClientProvider, &oauthtoken.Service{}, dsService)
 		require.NoError(t, err)

 		proxy.HandleRequest()
@@ -702,9 +699,9 @@ func TestNewDataSourceProxy_InvalidURL(t *testing.T) {
 		Url:  "://host/root",
 	}
 	cfg := setting.Cfg{}
-	plugin := plugins.DataSourcePlugin{}
+	var routes []*plugins.Route
 	dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-	_, err := NewDataSourceProxy(&ds, &plugin, &ctx, "api/method", &cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
+	_, err := NewDataSourceProxy(&ds, routes, &ctx, "api/method", &cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
 	require.Error(t, err)
 	assert.True(t, strings.HasPrefix(err.Error(), `validation of data source URL "://host/root" failed`))
 }
@@ -719,10 +716,10 @@ func TestNewDataSourceProxy_ProtocolLessURL(t *testing.T) {
 		Url:  "127.0.01:5432",
 	}
 	cfg := setting.Cfg{}
-	plugin := plugins.DataSourcePlugin{}

+	var routes []*plugins.Route
 	dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-	_, err := NewDataSourceProxy(&ds, &plugin, &ctx, "api/method", &cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
+	_, err := NewDataSourceProxy(&ds, routes, &ctx, "api/method", &cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)

 	require.NoError(t, err)
 }
@@ -754,14 +751,14 @@ func TestNewDataSourceProxy_MSSQL(t *testing.T) {
 	for _, tc := range tcs {
 		t.Run(tc.description, func(t *testing.T) {
 			cfg := setting.Cfg{}
-			plugin := plugins.DataSourcePlugin{}
 			ds := models.DataSource{
 				Type: "mssql",
 				Url:  tc.url,
 			}

+			var routes []*plugins.Route
 			dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-			p, err := NewDataSourceProxy(&ds, &plugin, &ctx, "api/method", &cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
+			p, err := NewDataSourceProxy(&ds, routes, &ctx, "api/method", &cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
 			if tc.err == nil {
 				require.NoError(t, err)
 				assert.Equal(t, &url.URL{
@@ -778,15 +775,14 @@ func TestNewDataSourceProxy_MSSQL(t *testing.T) {

 // getDatasourceProxiedRequest is a helper for easier setup of tests based on global config and ReqContext.
 func getDatasourceProxiedRequest(t *testing.T, ctx *models.ReqContext, cfg *setting.Cfg) *http.Request {
-	plugin := &plugins.DataSourcePlugin{}
-
 	ds := &models.DataSource{
 		Type: "custom",
 		Url:  "http://host/root/",
 	}

+	var routes []*plugins.Route
 	dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-	proxy, err := NewDataSourceProxy(ds, plugin, ctx, "", cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
+	proxy, err := NewDataSourceProxy(ds, routes, ctx, "", cfg, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
 	require.NoError(t, err)
 	req, err := http.NewRequest(http.MethodGet, "http://grafana.com/sub", nil)
 	require.NoError(t, err)
@@ -903,10 +899,10 @@ func createAuthTest(t *testing.T, dsType string, authType string, authCheck stri
 }

 func runDatasourceAuthTest(t *testing.T, test *testCase) {
-	plugin := &plugins.DataSourcePlugin{}
 	ctx := &models.ReqContext{}
+	var routes []*plugins.Route
 	dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-	proxy, err := NewDataSourceProxy(test.datasource, plugin, ctx, "", &setting.Cfg{}, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
+	proxy, err := NewDataSourceProxy(test.datasource, routes, ctx, "", &setting.Cfg{}, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
 	require.NoError(t, err)

 	req, err := http.NewRequest(http.MethodGet, "http://grafana.com/sub", nil)
@@ -919,22 +915,21 @@ func runDatasourceAuthTest(t *testing.T, test *testCase) {

 func Test_PathCheck(t *testing.T) {
 	// Ensure that we test routes appropriately. This test reproduces a historical bug where two routes were defined with different role requirements but the same method and the more privileged route was tested first. Here we ensure auth checks are applied based on the correct route, not just the method.
-	plugin := &plugins.DataSourcePlugin{
-		Routes: []*plugins.AppPluginRoute{
-			{
-				Path:    "a",
-				URL:     "https://www.google.com",
-				ReqRole: models.ROLE_EDITOR,
-				Method:  http.MethodGet,
-			},
-			{
-				Path:    "b",
-				URL:     "https://www.google.com",
-				ReqRole: models.ROLE_VIEWER,
-				Method:  http.MethodGet,
-			},
+	routes := []*plugins.Route{
+		{
+			Path:    "a",
+			URL:     "https://www.google.com",
+			ReqRole: models.ROLE_EDITOR,
+			Method:  http.MethodGet,
+		},
+		{
+			Path:    "b",
+			URL:     "https://www.google.com",
+			ReqRole: models.ROLE_VIEWER,
+			Method:  http.MethodGet,
 		},
 	}
+
 	setUp := func() (*models.ReqContext, *http.Request) {
 		req, err := http.NewRequest("GET", "http://localhost/asd", nil)
 		require.NoError(t, err)
@@ -946,11 +941,11 @@ func Test_PathCheck(t *testing.T) {
 	}
 	ctx, _ := setUp()
 	dsService := datasources.ProvideService(bus.New(), nil, ossencryption.ProvideService())
-	proxy, err := NewDataSourceProxy(&models.DataSource{}, plugin, ctx, "b", &setting.Cfg{}, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
+	proxy, err := NewDataSourceProxy(&models.DataSource{}, routes, ctx, "b", &setting.Cfg{}, httpclient.NewProvider(), &oauthtoken.Service{}, dsService)
 	require.NoError(t, err)

 	require.Nil(t, proxy.validateRequest())
-	require.Equal(t, plugin.Routes[1], proxy.route)
+	require.Equal(t, routes[1], proxy.matchedRoute)
 }

 type mockOAuthTokenService struct {
--- a/pkg/api/pluginproxy/pluginproxy.go
+++ b/pkg/api/pluginproxy/pluginproxy.go
@@ -21,7 +21,7 @@ type templateData struct {
 }

 // NewApiPluginProxy create a plugin proxy
-func NewApiPluginProxy(ctx *models.ReqContext, proxyPath string, route *plugins.AppPluginRoute,
+func NewApiPluginProxy(ctx *models.ReqContext, proxyPath string, route *plugins.Route,
 	appID string, cfg *setting.Cfg, encryptionService encryption.Service) *httputil.ReverseProxy {
 	director := func(req *http.Request) {
 		query := models.GetPluginSettingByIdQuery{OrgId: ctx.OrgId, PluginId: appID}
--- a/pkg/api/pluginproxy/pluginproxy_test.go
+++ b/pkg/api/pluginproxy/pluginproxy_test.go
@@ -18,8 +18,8 @@ import (

 func TestPluginProxy(t *testing.T) {
 	t.Run("When getting proxy headers", func(t *testing.T) {
-		route := &plugins.AppPluginRoute{
-			Headers: []plugins.AppPluginRouteHeader{
+		route := &plugins.Route{
+			Headers: []plugins.Header{
 				{Name: "x-header", Content: "my secret {{.SecureJsonData.key}}"},
 			},
 		}
@@ -124,7 +124,7 @@ func TestPluginProxy(t *testing.T) {
 	})

 	t.Run("When getting templated url", func(t *testing.T) {
-		route := &plugins.AppPluginRoute{
+		route := &plugins.Route{
 			URL:    "{{.JsonData.dynamicUrl}}",
 			Method: "GET",
 		}
@@ -159,7 +159,7 @@ func TestPluginProxy(t *testing.T) {
 	})

 	t.Run("When getting complex templated url", func(t *testing.T) {
-		route := &plugins.AppPluginRoute{
+		route := &plugins.Route{
 			URL:    "{{if .JsonData.apiHost}}{{.JsonData.apiHost}}{{else}}https://example.com{{end}}",
 			Method: "GET",
 		}
@@ -189,7 +189,7 @@ func TestPluginProxy(t *testing.T) {
 	})

 	t.Run("When getting templated body", func(t *testing.T) {
-		route := &plugins.AppPluginRoute{
+		route := &plugins.Route{
 			Path: "api/body",
 			URL:  "http://www.test.com",
 			Body: []byte(`{ "url": "{{.JsonData.dynamicUrl}}", "secret": "{{.SecureJsonData.key}}"	}`),
@@ -238,10 +238,10 @@ func TestPluginProxy(t *testing.T) {
 }

 // getPluginProxiedRequest is a helper for easier setup of tests based on global config and ReqContext.
-func getPluginProxiedRequest(t *testing.T, ctx *models.ReqContext, cfg *setting.Cfg, route *plugins.AppPluginRoute) *http.Request {
+func getPluginProxiedRequest(t *testing.T, ctx *models.ReqContext, cfg *setting.Cfg, route *plugins.Route) *http.Request {
 	// insert dummy route if none is specified
 	if route == nil {
-		route = &plugins.AppPluginRoute{
+		route = &plugins.Route{
 			Path:    "api/v4/",
 			URL:     "https://www.google.com",
 			ReqRole: models.ROLE_EDITOR,
--- a/pkg/api/pluginproxy/token_provider_azure.go
+++ b/pkg/api/pluginproxy/token_provider_azure.go
@@ -16,7 +16,7 @@ type azureAccessTokenProvider struct {
 	scopes        []string
 }

-func newAzureAccessTokenProvider(ctx context.Context, cfg *setting.Cfg, authParams *plugins.JwtTokenAuth) (*azureAccessTokenProvider, error) {
+func newAzureAccessTokenProvider(ctx context.Context, cfg *setting.Cfg, authParams *plugins.JWTTokenAuth) (*azureAccessTokenProvider, error) {
 	credentials := getAzureCredentials(cfg, authParams)
 	tokenProvider, err := aztokenprovider.NewAzureAccessTokenProvider(cfg, credentials)
 	if err != nil {
@@ -33,7 +33,7 @@ func (provider *azureAccessTokenProvider) GetAccessToken() (string, error) {
 	return provider.tokenProvider.GetAccessToken(provider.ctx, provider.scopes)
 }

-func getAzureCredentials(cfg *setting.Cfg, authParams *plugins.JwtTokenAuth) azcredentials.AzureCredentials {
+func getAzureCredentials(cfg *setting.Cfg, authParams *plugins.JWTTokenAuth) azcredentials.AzureCredentials {
 	authType := strings.ToLower(authParams.Params["azure_auth_type"])
 	clientId := authParams.Params["client_id"]

--- a/pkg/api/pluginproxy/token_provider_gce.go
+++ b/pkg/api/pluginproxy/token_provider_gce.go
@@ -12,8 +12,8 @@ type gceAccessTokenProvider struct {
 	ctx    context.Context
 }

-func newGceAccessTokenProvider(ctx context.Context, ds DSInfo, pluginRoute *plugins.AppPluginRoute,
-	authParams *plugins.JwtTokenAuth) *gceAccessTokenProvider {
+func newGceAccessTokenProvider(ctx context.Context, ds DSInfo, pluginRoute *plugins.Route,
+	authParams *plugins.JWTTokenAuth) *gceAccessTokenProvider {
 	cfg := googletokenprovider.Config{
 		RoutePath:         pluginRoute.Path,
 		RouteMethod:       pluginRoute.Method,
--- a/pkg/api/pluginproxy/token_provider_generic.go
+++ b/pkg/api/pluginproxy/token_provider_generic.go
@@ -27,8 +27,8 @@ type tokenCacheType struct {
 type genericAccessTokenProvider struct {
 	datasourceId      int64
 	datasourceUpdated time.Time
-	route             *plugins.AppPluginRoute
-	authParams        *plugins.JwtTokenAuth
+	route             *plugins.Route
+	authParams        *plugins.JWTTokenAuth
 }

 type jwtToken struct {
@@ -67,8 +67,8 @@ func (token *jwtToken) UnmarshalJSON(b []byte) error {
 	return nil
 }

-func newGenericAccessTokenProvider(ds DSInfo, pluginRoute *plugins.AppPluginRoute,
-	authParams *plugins.JwtTokenAuth) *genericAccessTokenProvider {
+func newGenericAccessTokenProvider(ds DSInfo, pluginRoute *plugins.Route,
+	authParams *plugins.JWTTokenAuth) *genericAccessTokenProvider {
 	return &genericAccessTokenProvider{
 		datasourceId:      ds.ID,
 		datasourceUpdated: ds.Updated,
--- a/pkg/api/pluginproxy/token_provider_jwt.go
+++ b/pkg/api/pluginproxy/token_provider_jwt.go
@@ -12,8 +12,8 @@ type jwtAccessTokenProvider struct {
 	ctx    context.Context
 }

-func newJwtAccessTokenProvider(ctx context.Context, ds DSInfo, pluginRoute *plugins.AppPluginRoute,
-	authParams *plugins.JwtTokenAuth) *jwtAccessTokenProvider {
+func newJwtAccessTokenProvider(ctx context.Context, ds DSInfo, pluginRoute *plugins.Route,
+	authParams *plugins.JWTTokenAuth) *jwtAccessTokenProvider {
 	jwtConf := &googletokenprovider.JwtTokenConfig{}
 	if val, ok := authParams.Params["client_email"]; ok {
 		jwtConf.Email = val
--- a/pkg/api/pluginproxy/token_provider_test.go
+++ b/pkg/api/pluginproxy/token_provider_test.go
@@ -23,11 +23,11 @@ func TestAccessToken_pluginWithTokenAuthRoute(t *testing.T) {
 	server := httptest.NewServer(apiHandler)
 	defer server.Close()

-	pluginRoute := &plugins.AppPluginRoute{
+	pluginRoute := &plugins.Route{
 		Path:   "pathwithtokenauth1",
 		URL:    "",
 		Method: "GET",
-		TokenAuth: &plugins.JwtTokenAuth{
+		TokenAuth: &plugins.JWTTokenAuth{
 			Url: server.URL + "/oauth/token",
 			Scopes: []string{
 				"https://www.testapi.com/auth/monitoring.read",
@@ -43,7 +43,7 @@ func TestAccessToken_pluginWithTokenAuthRoute(t *testing.T) {
 		},
 	}

-	authParams := &plugins.JwtTokenAuth{
+	authParams := &plugins.JWTTokenAuth{
 		Url: server.URL + "/oauth/token",
 		Scopes: []string{
 			"https://www.testapi.com/auth/monitoring.read",
--- a/pkg/api/pluginproxy/utils.go
+++ b/pkg/api/pluginproxy/utils.go
@@ -38,7 +38,7 @@ func interpolateString(text string, data templateData) (string, error) {
 }

 // addHeaders interpolates route headers and injects them into the request headers
-func addHeaders(reqHeaders *http.Header, route *plugins.AppPluginRoute, data templateData) error {
+func addHeaders(reqHeaders *http.Header, route *plugins.Route, data templateData) error {
 	for _, header := range route.Headers {
 		interpolated, err := interpolateString(header.Content, data)
 		if err != nil {
@@ -51,7 +51,7 @@ func addHeaders(reqHeaders *http.Header, route *plugins.AppPluginRoute, data tem
 }

 // addQueryString interpolates route params and injects them into the request object
-func addQueryString(req *http.Request, route *plugins.AppPluginRoute, data templateData) error {
+func addQueryString(req *http.Request, route *plugins.Route, data templateData) error {
 	q := req.URL.Query()
 	for _, param := range route.URLParams {
 		interpolatedName, err := interpolateString(param.Name, data)
@@ -71,7 +71,7 @@ func addQueryString(req *http.Request, route *plugins.AppPluginRoute, data templ
 	return nil
 }

-func setBodyContent(req *http.Request, route *plugins.AppPluginRoute, data templateData) error {
+func setBodyContent(req *http.Request, route *plugins.Route, data templateData) error {
 	if route.Body != nil {
 		interpolatedBody, err := interpolateString(string(route.Body), data)
 		if err != nil {