Feat: add open in Sift button to grafana query builder (#31)

Author: leo-sift

.github/workflows/release.yml

@@ -2,7 +2,6 @@
 # (For more information, see https://github.com/grafana/plugin-actions/blob/main/build-plugin/README.md)
 name: Release
 
-
 on:
   push:
     tags:
@@ -22,4 +21,4 @@ jobs:
       - uses: grafana/plugin-actions/build-plugin@main
         with:
           policy_token: ${{ secrets.GRAFANA_ACCESS_POLICY_TOKEN }}
-          attestation: true
+          attestation: true

.gitignore

@@ -30,6 +30,8 @@ tmp/
 **/cypress/videos
 **/cypress/report.json
 
+test-results/
+
 # Editor
 .idea
 .vscode/*

README.md

@@ -37,7 +37,6 @@ Enter these values when creating the datasource in Grafana.
 5. Query will be run after selection or clicking outside the input or by clicking the Refresh button
 6. Additional Queries can be added using the "Add Query" button to use both Channel and Calculated Channel queries in the same panel
 
-
 #### Selection Types
 
 Selection of Assets, Runs, and Channels can be done using multiple different input types. Input type may be changed using the "Change input type" button.
@@ -79,7 +78,7 @@ the string value of the variable when the query is executed.
 
 #### Caching
 
-To improve performance, queries are cached by panel for a given query and associated interval (sample rate). If the 
+To improve performance, queries are cached by panel for a given query and associated interval (sample rate). If the
 query range changes, but the query is otherwise the same, only the missing data on either side will be fetched. In the case
 where the right side of the query range is close to live, new data will always be queried for data between now and the last 10 minutes.
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "sift-grafana-datasource",
-  "version": "1.2.12",
+  "version": "1.3.0",
   "description": "",
   "scripts": {
     "build": "webpack -c ./.config/webpack/webpack.config.ts --env production",
@@ -12,7 +12,7 @@
     "lint": "eslint --cache --ignore-path ./.gitignore --ext .js,.jsx,.ts,.tsx .",
     "lint:fix": "npm run lint -- --fix && prettier --write --list-different .",
     "lint:backend": "golangci-lint run --timeout=5m",
-    "e2e": "playwright test",
+    "e2": "echo disabled. original command: playright test",
     "server": "docker-compose up --build",
     "server:watch": "docker-compose up -d --build && (docker-compose logs -f & ./dev-watch.sh)",
     "sign": "npx --yes @grafana/sign-plugin@latest"
@@ -27,7 +27,6 @@
     "@grafana/plugin-e2e": "^1.17.1",
     "@grafana/plugin-meta-extractor": "^0.0.2",
     "@grafana/tsconfig": "^2.0.0",
-    "@playwright/test": "1.52.0",
     "@stylistic/eslint-plugin-ts": "^2.9.0",
     "@swc/core": "^1.3.90",
     "@swc/helpers": "^0.5.0",
@@ -85,6 +84,7 @@
     "@grafana/runtime": "^11.5.3",
     "@grafana/schema": "^11.5.3",
     "@grafana/ui": "^11.5.3",
+    "@playwright/test": "^1.52.0",
     "leven": "^4.0.0",
     "luxon": "^3.6.1",
     "nanoid": "^5.1.5",
@@ -99,4 +99,4 @@
     "form-data": "^4.0.4"
   },
   "packageManager": "npm@9.8.0"
-}
+}

package.json

@@ -154,6 +154,9 @@ func (d *SiftDatasource) CallResource(ctx context.Context, req *backend.CallReso
 	case "purge-cache":
 		return d.callPurgeCache(ctx, req, sender)
 
+	case "resolve-query-to-sift-metadata":
+		return d.resolveQueryToSiftMetadata(ctx, req, sender)
+
 	default:
 		return sender.Send(&backend.CallResourceResponse{
 			Status: http.StatusNotFound,
@@ -192,7 +195,8 @@ func (d *SiftDatasource) QueryData(ctx context.Context, req *backend.QueryDataRe
 }
 
 type jsonData struct {
-	Url string `json:"url"`
+	Url         string `json:"url"`
+	FrontendUrl string `json:"frontendUrl"`
 }
 
 type commonQueryProperties struct {
@@ -502,6 +506,18 @@ func generateQueries(pCtx backend.PluginContext, fqm queryModel, d *SiftDatasour
 	return queries, calculatedChannelKeys, nil
 }
 
+func sortedKeys(set map[string]struct{}) []string {
+	if len(set) == 0 {
+		return []string{}
+	}
+	result := make([]string, 0, len(set))
+	for k := range set {
+		result = append(result, k)
+	}
+	slices.Sort(result)
+	return result
+}
+
 func splitQueries(queries []siftApiGetDataSubQuery, chunkSize int) [][]siftApiGetDataSubQuery {
 	var chunks [][]siftApiGetDataSubQuery
 	for i := 0; i < len(queries); i += chunkSize {

pkg/plugin/datasource.go

@@ -4,14 +4,14 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
 	"net/http"
 	"net/url"
 	"regexp"
 	"strconv"
 	"strings"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
+	"github.com/grafana/grafana-plugin-sdk-go/backend/log"
 )
 
 // Limit number of results that can be returned from the Sift API
@@ -167,3 +167,179 @@ func (d *SiftDatasource) callPurgeCache(ctx context.Context, req *backend.CallRe
 		Body:   []byte("{}"),
 	})
 }
+
+type calculatedChannelMetadata struct {
+	Name               string   `json:"name"`
+	SourceChannels     []string `json:"sourceChannels"`
+	Expression         string   `json:"expression"`
+	ExpressionDataType string   `json:"expressionDataType"`
+}
+
+func (d *SiftDatasource) resolveQueryToSiftMetadata(ctx context.Context, req *backend.CallResourceRequest, sender backend.CallResourceResponseSender) error {
+	log.DefaultLogger.Debug("resolveQueryToSiftMetadata request", "body", string(req.Body))
+
+	queryModel, err := convertQueryIfNeeded(json.RawMessage(req.Body))
+	if err != nil {
+		log.DefaultLogger.Error("resolveQueryToSiftMetadata convert error", "error", err)
+		return sender.Send(&backend.CallResourceResponse{
+			Status: http.StatusBadRequest,
+			Body:   []byte(fmt.Sprintf("parse query: %s", err)),
+		})
+	}
+
+	queries, calculatedKeys, err := generateQueries(req.PluginContext, *queryModel, d)
+	if err != nil {
+		log.DefaultLogger.Error("resolveQueryToSiftMetadata generateQueries error", "error", err)
+		return sender.Send(&backend.CallResourceResponse{
+			Status: http.StatusBadRequest,
+			Body:   []byte(fmt.Sprintf("generate queries: %s", err)),
+		})
+	}
+
+	assetIDSet := make(map[string]struct{})
+	runIDSet := make(map[string]struct{})
+	channelIDSet := make(map[string]struct{})
+	order := make([]string, 0, len(calculatedKeys))
+	metaByName := make(map[string]*calculatedChannelMetadata)
+
+	for _, subQuery := range queries {
+		calc := subQuery.CalculatedChannel
+		if subQuery.Channel != nil {
+			channelID := strings.TrimSpace(subQuery.Channel.ChannelId)
+			if channelID != "" {
+				channelIDSet[channelID] = struct{}{}
+			}
+			if subQuery.Channel.RunId != nil {
+				if runID := strings.TrimSpace(*subQuery.Channel.RunId); runID != "" {
+					runIDSet[runID] = struct{}{}
+				}
+			}
+		}
+
+		if calc == nil {
+			continue
+		}
+
+		if calc.RunId != nil {
+			if runID := strings.TrimSpace(*calc.RunId); runID != "" {
+				runIDSet[runID] = struct{}{}
+			}
+		}
+
+		name := strings.TrimSpace(calc.ChannelKey)
+		if key, ok := calculatedKeys[calc.ChannelKey]; ok {
+			if trimmed := strings.TrimSpace(key.channelName); trimmed != "" {
+				name = trimmed
+			}
+		}
+		if name == "" {
+			continue
+		}
+
+		refs := calc.ExpressionRequest.ExpressionChannelReferences
+		expr := strings.TrimSpace(calc.ExpressionRequest.Expression)
+
+		meta, exists := metaByName[name]
+		if !exists {
+			meta = &calculatedChannelMetadata{
+				Name:               name,
+				SourceChannels:     make([]string, len(refs)),
+				ExpressionDataType: "double",
+			}
+			metaByName[name] = meta
+			order = append(order, name)
+		} else if len(meta.SourceChannels) != len(refs) {
+			meta.SourceChannels = make([]string, len(refs))
+		}
+
+		meta.Expression = expr
+
+		for idx, ref := range refs {
+			channelID := strings.TrimSpace(ref.ChannelId)
+			if channelID == "" {
+				continue
+			}
+			channelIDSet[channelID] = struct{}{}
+			if meta.SourceChannels[idx] == "" {
+				meta.SourceChannels[idx] = channelID
+			}
+		}
+	}
+
+	channelIDs := make([]string, 0, len(channelIDSet))
+	for channelID := range channelIDSet {
+		channelIDs = append(channelIDs, channelID)
+	}
+
+	if len(channelIDs) > 0 {
+		channels, err := d.getChannelsById(req.PluginContext, channelIDs)
+		if err != nil {
+			log.DefaultLogger.Error("resolveQueryToSiftMetadata channel lookup error", "error", err)
+			return sender.Send(&backend.CallResourceResponse{
+				Status: http.StatusBadRequest,
+				Body:   []byte(fmt.Sprintf("lookup channels: %s", err)),
+			})
+		}
+		for _, channel := range channels {
+			assetID := strings.TrimSpace(channel.AssetId)
+			if assetID != "" {
+				assetIDSet[assetID] = struct{}{}
+			}
+		}
+	}
+
+	assetIDs := sortedKeys(assetIDSet)
+	runIDs := sortedKeys(runIDSet)
+	channelIDsSorted := sortedKeys(channelIDSet)
+
+	log.DefaultLogger.Debug(
+		"resolveQueryToSiftMetadata summary",
+		"assetIds", assetIDs,
+		"runIds", runIDs,
+		"channelIds", channelIDsSorted,
+	)
+
+	var calculatedChannels []calculatedChannelMetadata
+	for _, name := range order {
+		meta := metaByName[name]
+		if meta.Expression == "" {
+			continue
+		}
+
+		complete := true
+		for _, channelID := range meta.SourceChannels {
+			if channelID == "" {
+				complete = false
+				break
+			}
+		}
+		if complete {
+			calculatedChannels = append(calculatedChannels, *meta)
+		}
+	}
+
+	responsePayload := struct {
+		AssetIDs           []string                    `json:"assetIds"`
+		RunIDs             []string                    `json:"runIds"`
+		ChannelIDs         []string                    `json:"channelIds"`
+		CalculatedChannels []calculatedChannelMetadata `json:"calculatedChannels,omitempty"`
+	}{
+		AssetIDs:           assetIDs,
+		RunIDs:             runIDs,
+		ChannelIDs:         channelIDsSorted,
+		CalculatedChannels: calculatedChannels,
+	}
+
+	body, err := json.Marshal(responsePayload)
+	if err != nil {
+		return sender.Send(&backend.CallResourceResponse{
+			Status: http.StatusInternalServerError,
+			Body:   []byte(fmt.Sprintf("encode response: %s", err)),
+		})
+	}
+
+	return sender.Send(&backend.CallResourceResponse{
+		Status: http.StatusOK,
+		Body:   body,
+	})
+}

pkg/plugin/resources.go

@@ -49,4 +49,4 @@ export default defineConfig({
       dependencies: ['auth'],
     },
   ],
-});
+});