add timeout; return no results if no results were found

Author: kminehart

datasource.go

@@ -3,23 +3,27 @@ package sqlds
 import (
 	"context"
 	"database/sql"
+	"errors"
+	"fmt"
 	"net/http"
 	"sync"
+	"time"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/instancemgmt"
 	"github.com/grafana/grafana-plugin-sdk-go/backend/resource/httpadapter"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
-	"github.com/pkg/errors"
 )
 
 type sqldatasource struct {
+	Completable
+
 	db       *sql.DB
 	c        Driver
 	settings backend.DataSourceInstanceSettings
+	timeout  time.Duration
 
 	backend.CallResourceHandler
-	Completable
 	CustomRoutes map[string]func(http.ResponseWriter, *http.Request)
 }
 
@@ -37,7 +41,9 @@ func (ds *sqldatasource) NewDatasource(settings backend.DataSourceInstanceSettin
 	if err != nil {
 		return nil, err
 	}
+
 	ds.CallResourceHandler = httpadapter.New(mux)
+	ds.timeout = ds.c.Timeout(settings)
 
 	return ds, nil
 }
@@ -66,7 +72,7 @@ func (ds *sqldatasource) QueryData(ctx context.Context, req *backend.QueryDataRe
 	// Execute each query and store the results by query RefID
 	for _, q := range req.Queries {
 		go func(query backend.DataQuery) {
-			frames, err := ds.handleQuery(query)
+			frames, err := ds.handleQuery(ctx, query)
 
 			response.Set(query.RefID, backend.DataResponse{
 				Frames: frames,
@@ -83,7 +89,7 @@ func (ds *sqldatasource) QueryData(ctx context.Context, req *backend.QueryDataRe
 }
 
 // handleQuery will call query, and attempt to reconnect if the query failed
-func (ds *sqldatasource) handleQuery(req backend.DataQuery) (data.Frames, error) {
+func (ds *sqldatasource) handleQuery(ctx context.Context, req backend.DataQuery) (data.Frames, error) {
 	// Convert the backend.DataQuery into a Query object
 	q, err := GetQuery(req)
 	if err != nil {
@@ -93,7 +99,7 @@ func (ds *sqldatasource) handleQuery(req backend.DataQuery) (data.Frames, error)
 	// Apply supported macros to the query
 	q.RawSQL, err = interpolate(ds.c, q)
 	if err != nil {
-		return nil, errors.WithMessage(err, "Could not apply macros")
+		return nil, fmt.Errorf("%s: %w", "Could not apply macros", err)
 	}
 
 	// Apply the default FillMode, overwritting it if the query specifies it
@@ -102,21 +108,35 @@ func (ds *sqldatasource) handleQuery(req backend.DataQuery) (data.Frames, error)
 		fillMode = q.FillMissing
 	}
 
+	if ds.timeout != 0 {
+		tctx, cancel := context.WithTimeout(ctx, ds.timeout)
+		defer cancel()
+
+		ctx = tctx
+	}
+
 	// FIXES:
 	//  * Some datasources (snowflake) expire connections or have an authentication token that expires if not used in 1 or 4 hours.
 	//    Because the datasource driver does not include an option for permanent connections, we retry the connection
 	//    if the query fails. NOTE: this does not include some errors like "ErrNoRows"
-	res, err := query(ds.db, ds.c.Converters(), fillMode, q)
+
+	// This function will return an "ErrorTimeout" if the context's done channel receives data
+	res, err := queryContext(ctx, ds.db, ds.c.Converters(), fillMode, q)
 	if err == nil {
 		return res, nil
 	}
 
-	if errors.Cause(err) == ErrorQuery {
+	if errors.Is(err, ErrorNoResults) {
+		return nil, nil
+	}
+
+	if errors.Is(err, ErrorQuery) {
 		ds.db, err = ds.c.Connect(ds.settings)
 		if err != nil {
 			return nil, err
 		}
-		return query(ds.db, ds.c.Converters(), fillMode, q)
+
+		return queryContext(ctx, ds.db, ds.c.Converters(), fillMode, q)
 	}
 
 	return nil, err

driver.go

@@ -2,6 +2,7 @@ package sqlds
 
 import (
 	"database/sql"
+	"time"
 
 	"github.com/grafana/grafana-plugin-sdk-go/backend"
 	"github.com/grafana/grafana-plugin-sdk-go/data"
@@ -13,7 +14,9 @@ import (
 type Driver interface {
 	// Connect connects to the database. It does not need to call `db.Ping()`
 	Connect(backend.DataSourceInstanceSettings) (*sql.DB, error)
+	Timeout(backend.DataSourceInstanceSettings) time.Duration
 	FillMode() *data.FillMissing
 	Macros() Macros
 	Converters() []sqlutil.Converter
+	// Timeout is used when sending a query to the backing data source. If the timeout is exceeded, the QueryData function will return an error.
 }

errors.go

@@ -9,4 +9,8 @@ var (
 	ErrorJSON = errors.New("error unmarshaling query JSON the Query Model")
 	// ErrorQuery is returned when the query could not complete / execute
 	ErrorQuery = errors.New("error querying the database")
+	// ErrorTimeout is returned if the query has timed out
+	ErrorTimeout = errors.New("query timeout exceeded")
+	// ErrorNoResults is returned if there were no results returned
+	ErrorNoResults = errors.New("no results returned from query")
 )

query.go

@@ -1,14 +1,15 @@
 package sqlds
 
 import (
+	"context"
 	"database/sql"
 	"encoding/json"
+	"fmt"
 	"time"
 
 	"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"
-	"github.com/pkg/errors"
 )
 
 // FormatQueryOption defines how the user has chosen to represent the data
@@ -90,22 +91,44 @@ func getErrorFrameFromQuery(query *Query) data.Frames {
 	return frames
 }
 
+func queryContext(ctx context.Context, db *sql.DB, converters []sqlutil.Converter, fillMode *data.FillMissing, q *Query) (data.Frames, error) {
+	var (
+		done = make(chan bool)
+		res  = data.Frames{}
+		err  error
+	)
+
+	go func() {
+		res, err = query(ctx, db, converters, fillMode, q)
+		done <- true
+	}()
+
+	select {
+	case <-done:
+		// The done channel will receive data if the query funciton has completed
+		return res, err
+	case <-ctx.Done():
+		// The context's done channel will receive data if the timeout is exceeded
+		return nil, ErrorTimeout
+	}
+}
+
 // query sends the query to the sql.DB and converts the rows to a dataframe.
-func query(db *sql.DB, converters []sqlutil.Converter, fillMode *data.FillMissing, query *Query) (data.Frames, error) {
+func query(ctx context.Context, db *sql.DB, converters []sqlutil.Converter, fillMode *data.FillMissing, query *Query) (data.Frames, error) {
 	// Query the rows from the database
-	rows, err := db.Query(query.RawSQL)
+	rows, err := db.QueryContext(ctx, query.RawSQL)
 	if err != nil {
-		return getErrorFrameFromQuery(query), errors.Wrap(ErrorQuery, err.Error())
+		return getErrorFrameFromQuery(query), fmt.Errorf("%w: %s", ErrorQuery, err.Error())
 	}
 
 	// Check for an error response
 	if err := rows.Err(); err != nil {
 		if err == sql.ErrNoRows {
 			// Should we even response with an error here?
 			// The panel will simply show "no data"
-			return getErrorFrameFromQuery(query), errors.WithMessage(err, "No results from query")
+			return getErrorFrameFromQuery(query), fmt.Errorf("%s: %w", "No results from query", err)
 		}
-		return getErrorFrameFromQuery(query), errors.WithMessage(err, "Error response from database")
+		return getErrorFrameFromQuery(query), fmt.Errorf("%s: %w", "Error response from database", err)
 	}
 
 	defer func() {
@@ -117,7 +140,7 @@ func query(db *sql.DB, converters []sqlutil.Converter, fillMode *data.FillMissin
 	// Convert the response to frames
 	res, err := getFrames(rows, -1, converters, fillMode, query)
 	if err != nil {
-		return nil, errors.WithMessage(err, "Could not process SQL results")
+		return nil, fmt.Errorf("%w: %s", err, "Could not process SQL results")
 	}
 
 	return res, nil
@@ -139,6 +162,16 @@ func getFrames(rows *sql.Rows, limit int64, converters []sqlutil.Converter, fill
 		return data.Frames{frame}, nil
 	}
 
+	count, err := frame.RowLen()
+
+	if err != nil {
+		return nil, err
+	}
+
+	if count == 0 {
+		return nil, ErrorNoResults
+	}
+
 	if frame.TimeSeriesSchema().Type == data.TimeSeriesTypeLong {
 		frame, err := data.LongToWide(frame, fillMode)
 		if err != nil {