Add a multi timeseries return format (#106)

Author: iwysiu

go.mod

@@ -7,6 +7,7 @@ toolchain go1.21.1
 require (
 	github.com/go-sql-driver/mysql v1.4.0
 	github.com/google/go-cmp v0.5.9
+	github.com/grafana/dataplane/sdata v0.0.7
 	github.com/grafana/grafana-plugin-sdk-go v0.188.3
 	github.com/mithrandie/csvq-driver v1.6.8
 	github.com/stretchr/testify v1.8.4

go.sum

@@ -98,6 +98,8 @@ github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e h1:JKmoR8x90Iww1
 github.com/gopherjs/gopherjs v0.0.0-20181103185306-d547d1d9531e/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
 github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI=
 github.com/gorilla/mux v1.8.0/go.mod h1:DVbg23sWSpFRCP0SfiEN6jmj59UnW/n46BH5rLB71So=
+github.com/grafana/dataplane/sdata v0.0.7 h1:CImITypIyS1jxijCR6xqKx71JnYAxcwpH9ChK0gH164=
+github.com/grafana/dataplane/sdata v0.0.7/go.mod h1:Jvs5ddpGmn6vcxT7tCTWAZ1mgi4sbcdFt9utQx5uMAU=
 github.com/grafana/grafana-plugin-sdk-go v0.188.3 h1:91wrmnS6zXs4FhriVesZujkmjrwY1xhsusL30CtLkEE=
 github.com/grafana/grafana-plugin-sdk-go v0.188.3/go.mod h1:nctofuR6fyhx3Stbnh5ha6setroeqqBgO0Rj9s4t86o=
 github.com/grpc-ecosystem/go-grpc-middleware v1.4.0 h1:UH//fgunKIs4JdUbpDl1VZCDaL56wXCB/5+wF6uHfaI=

query.go

@@ -9,6 +9,8 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/grafana/dataplane/sdata/timeseries"
+
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
 	"github.com/grafana/grafana-plugin-sdk-go/data/sqlutil"
@@ -18,14 +20,16 @@ import (
 type FormatQueryOption uint32
 
 const (
-	// FormatOptionTimeSeries formats the query results as a timeseries using "WideToLong"
+	// FormatOptionTimeSeries formats the query results as a timeseries using "LongToWide"
 	FormatOptionTimeSeries FormatQueryOption = iota
-	// FormatOptionTable formats the query results as a table using "LongToWide"
+	// FormatOptionTable sets the preferred visualization to table
 	FormatOptionTable
 	// FormatOptionLogs sets the preferred visualization to logs
 	FormatOptionLogs
 	// FormatOptionsTrace sets the preferred visualization to trace
 	FormatOptionTrace
+	// FormatOptionMulti formats the query results as a timeseries using "LongToMulti"
+	FormatOptionMulti
 )
 
 // Query is the model that represents the query that users submit from the panel / queryeditor.
@@ -155,43 +159,84 @@ func getFrames(rows *sql.Rows, limit int64, converters []sqlutil.Converter, fill
 		frame.Meta = &data.FrameMeta{}
 	}
 
+	count, err := frame.RowLen()
+	if err != nil {
+		return nil, err
+	}
+	if count == 0 {
+		return nil, ErrorNoResults
+	}
+
 	frame.Meta.ExecutedQueryString = query.RawSQL
 	frame.Meta.PreferredVisualization = data.VisTypeGraph
 
-	if query.Format == FormatOptionTable {
-		frame.Meta.PreferredVisualization = data.VisTypeTable
-		return data.Frames{frame}, nil
-	}
+	switch query.Format {
+	case FormatOptionMulti:
+		if frame.TimeSeriesSchema().Type == data.TimeSeriesTypeLong {
 
-	if query.Format == FormatOptionLogs {
-		frame.Meta.PreferredVisualization = data.VisTypeLogs
-		return data.Frames{frame}, nil
-	}
+			err = fixFrameForLongToMulti(frame)
+			if err != nil {
+				return nil, err
+			}
 
-	if query.Format == FormatOptionTrace {
+			frames, err := timeseries.LongToMulti(&timeseries.LongFrame{frame})
+			if err != nil {
+				return nil, err
+			}
+			return frames.Frames(), nil
+		}
+	case FormatOptionTable:
+		frame.Meta.PreferredVisualization = data.VisTypeTable
+	case FormatOptionLogs:
+		frame.Meta.PreferredVisualization = data.VisTypeLogs
+	case FormatOptionTrace:
 		frame.Meta.PreferredVisualization = data.VisTypeTrace
-		return data.Frames{frame}, nil
+	// Format as timeSeries
+	default:
+		if frame.TimeSeriesSchema().Type == data.TimeSeriesTypeLong {
+			frame, err = data.LongToWide(frame, fillMode)
+			if err != nil {
+				return nil, err
+			}
+		}
 	}
+	return data.Frames{frame}, nil
+}
 
-	count, err := frame.RowLen()
-
-	if err != nil {
-		return nil, err
+// fixFrameForLongToMulti edits the passed in frame so that it's first time field isn't nullable and has the correct meta
+func fixFrameForLongToMulti(frame *data.Frame) error {
+	if frame == nil {
+		return fmt.Errorf("can not convert to wide series, input is nil")
 	}
 
-	if count == 0 {
-		return nil, ErrorNoResults
+	timeFields := frame.TypeIndices(data.FieldTypeTime, data.FieldTypeNullableTime)
+	if len(timeFields) == 0 {
+		return fmt.Errorf("can not convert to wide series, input is missing a time field")
 	}
 
-	if frame.TimeSeriesSchema().Type == data.TimeSeriesTypeLong {
-		frame, err := data.LongToWide(frame, fillMode)
-		if err != nil {
-			return nil, err
+	// the timeseries package expects the first time field in the frame to be non-nullable and ignores the rest
+	timeField := frame.Fields[timeFields[0]]
+	if timeField.Type() == data.FieldTypeNullableTime {
+		newValues := []time.Time{}
+		for i := 0; i < timeField.Len(); i++ {
+			val, ok := timeField.ConcreteAt(i)
+			if !ok {
+				return fmt.Errorf("can not convert to wide series, input has null time values")
+			}
+			newValues = append(newValues, val.(time.Time))
 		}
-		return data.Frames{frame}, nil
-	}
+		newField := data.NewField(timeField.Name, timeField.Labels, newValues)
+		newField.Config = timeField.Config
+		frame.Fields[timeFields[0]] = newField
 
-	return data.Frames{frame}, nil
+		// LongToMulti requires the meta to be set for the frame
+		if frame.Meta == nil {
+			frame.Meta = &data.FrameMeta{}
+		}
+		frame.Meta.Type = data.FrameTypeTimeSeriesLong
+		frame.Meta.TypeVersion = data.FrameTypeVersion{0, 1}
+	}
+	return nil
 }
 
 func applyHeaders(query *Query, headers http.Header) *Query {

query_test.go

@@ -4,10 +4,13 @@ import (
 	"context"
 	"database/sql"
 	"errors"
+	"fmt"
 	"testing"
 	"time"
 
+	"github.com/grafana/grafana-plugin-sdk-go/data"
 	"github.com/grafana/grafana-plugin-sdk-go/data/sqlutil"
+	"github.com/stretchr/testify/require"
 )
 
 var (
@@ -104,3 +107,48 @@ func TestQuery_Timeout(t *testing.T) {
 		}
 	})
 }
+
+func TestFixFrameForLongToMulti(t *testing.T) {
+	t.Run("fix time", func(t *testing.T) {
+		time1 := time.UnixMilli(1)
+		time2 := time.UnixMilli(2)
+		frame := data.NewFrame("",
+			data.NewField("time", nil, []*time.Time{&time1, &time2}),
+			data.NewField("host", nil, []string{"a", "b"}),
+			data.NewField("iface", nil, []string{"eth0", "eth0"}),
+			data.NewField("in_bytes", nil, []float64{1, 2}),
+			data.NewField("out_bytes", nil, []int64{3, 4}),
+		)
+
+		err := fixFrameForLongToMulti(frame)
+		require.NoError(t, err)
+
+		require.Equal(t, frame.Fields[0].Type(), data.FieldTypeTime)
+		require.Equal(t, frame.Fields[0].Len(), 2)
+		require.Equal(t, frame.Fields[0].At(0).(time.Time), time1)
+		require.Equal(t, frame.Fields[0].At(1).(time.Time), time2)
+
+		require.Equal(t, frame.Meta.Type, data.FrameTypeTimeSeriesLong)
+		require.Equal(t, frame.Meta.TypeVersion, data.FrameTypeVersion{0, 1})
+	})
+	t.Run("errors for null time", func(t *testing.T) {
+		time1 := time.UnixMilli(1)
+		frame := data.NewFrame("",
+			data.NewField("time", nil, []*time.Time{&time1, nil}),
+			data.NewField("host", nil, []string{"a", "b"}),
+			data.NewField("in_bytes", nil, []float64{1, 2}),
+		)
+
+		err := fixFrameForLongToMulti(frame)
+		require.Equal(t, err, fmt.Errorf("can not convert to wide series, input has null time values"))
+	})
+	t.Run("error for no time", func(t *testing.T) {
+		frame := data.NewFrame("",
+			data.NewField("host", nil, []string{"a", "b"}),
+			data.NewField("in_bytes", nil, []float64{1, 2}),
+		)
+
+		err := fixFrameForLongToMulti(frame)
+		require.Equal(t, err, fmt.Errorf("can not convert to wide series, input is missing a time field"))
+	})
+}