Removed read instant handler.

src/query/api/v1/handler/prom/common.go

@@ -53,7 +53,7 @@ const (
 
 type errorType string
 
-type queryData struct {
+type QueryData struct {
 	ResultType promql.ValueType `json:"resultType"`
 	Result     promql.Value     `json:"result"`
 }
@@ -66,7 +66,7 @@ type response struct {
 	Warnings  []string    `json:"warnings,omitempty"`
 }
 
-func respond(w http.ResponseWriter, data interface{}, warnings promstorage.Warnings) {
+func Respond(w http.ResponseWriter, data interface{}, warnings promstorage.Warnings) {
 	statusMessage := statusSuccess
 	var warningStrings []string
 	for _, warning := range warnings {
@@ -88,7 +88,7 @@ func respond(w http.ResponseWriter, data interface{}, warnings promstorage.Warni
 	w.Write(b)
 }
 
-func respondError(w http.ResponseWriter, err error) {
+func RespondError(w http.ResponseWriter, err error) {
 	json := jsoniter.ConfigCompatibleWithStandardLibrary
 	b, marshalErr := json.Marshal(&response{
 		Status: statusError,

src/query/api/v1/handler/prom/prom.go

@@ -41,6 +41,14 @@ func init() {
 // Options defines options for PromQL handler.
 type Options struct {
 	PromQLEngine *promql.Engine
+	instant bool
+}
+
+func (o Options) WithInstant(instant bool) Options {
+	return Options{
+		PromQLEngine: o.PromQLEngine,
+		instant:      instant,
+	}
 }
 
 // NewReadHandler creates a handler to handle PromQL requests.
@@ -59,17 +67,8 @@ func NewReadHandlerWithHooks(
 			Storage:           hOpts.Storage(),
 			InstrumentOptions: hOpts.InstrumentOpts(),
 		})
-	return newReadHandler(opts, hOpts, hooks, queryable)
-}
 
-// NewReadInstantHandler creates a handler to handle PromQL requests.
-func NewReadInstantHandler(opts Options, hOpts options.HandlerOptions) http.Handler {
-	queryable := prometheus.NewPrometheusQueryable(
-		prometheus.PrometheusOptions{
-			Storage:           hOpts.Storage(),
-			InstrumentOptions: hOpts.InstrumentOpts(),
-		})
-	return newReadInstantHandler(opts, hOpts, queryable)
+	return newReadHandler(opts, hOpts, hooks, queryable)
 }
 
 // ApplyRangeWarnings applies warnings encountered during execution.

src/query/api/v1/handler/prom/read.go

@@ -50,13 +50,47 @@ type ReadHandlerHooks interface {
 	) (models.RequestParams, error)
 }
 
+type NewQueryFn func(
+	engine *promql.Engine,
+	queryable promstorage.Queryable,
+	params models.RequestParams,
+) (promql.Query, error)
+
+var (
+	newRangeQueryFn = func(
+		engine *promql.Engine,
+		queryable promstorage.Queryable,
+		params models.RequestParams,
+	) (promql.Query, error) {
+		return engine.NewRangeQuery(
+			queryable,
+			params.Query,
+			params.Start,
+			params.End,
+			params.Step)
+	}
+
+	newInstantQueryFn = func(
+		engine *promql.Engine,
+		queryable promstorage.Queryable,
+		params models.RequestParams,
+	) (promql.Query, error) {
+		return engine.NewInstantQuery(
+			queryable,
+			params.Query,
+			params.Now)
+	}
+)
+
 type readHandler struct {
-	engine    *promql.Engine
-	hooks     ReadHandlerHooks
-	queryable promstorage.Queryable
-	hOpts     options.HandlerOptions
-	scope     tally.Scope
-	logger    *zap.Logger
+	engine     *promql.Engine
+	hooks      ReadHandlerHooks
+	queryable  promstorage.Queryable
+	newQueryFn NewQueryFn
+	hOpts      options.HandlerOptions
+	scope      tally.Scope
+	logger     *zap.Logger
+	opts       Options
 }
 
 func newReadHandler(
@@ -68,13 +102,21 @@ func newReadHandler(
 	scope := hOpts.InstrumentOpts().MetricsScope().Tagged(
 		map[string]string{"handler": "prometheus-read"},
 	)
+
+	newQueryFn := newRangeQueryFn
+	if opts.instant {
+		newQueryFn = newInstantQueryFn
+	}
+
 	return &readHandler{
-		engine:    opts.PromQLEngine,
-		hooks:     hooks,
-		queryable: queryable,
-		hOpts:     hOpts,
-		scope:     scope,
-		logger:    hOpts.InstrumentOpts().Logger(),
+		engine:     opts.PromQLEngine,
+		hooks:      hooks,
+		queryable:  queryable,
+		newQueryFn: newQueryFn,
+		hOpts:      hOpts,
+		opts:       opts,
+		scope:      scope,
+		logger:     hOpts.InstrumentOpts().Logger(),
 	}
 }
 
@@ -83,19 +125,19 @@ func (h *readHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	fetchOptions, err := h.hOpts.FetchOptionsBuilder().NewFetchOptions(r)
 	if err != nil {
-		respondError(w, err)
+		RespondError(w, err)
 		return
 	}
 
-	request, err := native.ParseRequest(ctx, r, false, h.hOpts)
+	request, err := native.ParseRequest(ctx, r, h.opts.instant, h.hOpts)
 	if err != nil {
-		respondError(w, err)
+		RespondError(w, err)
 		return
 	}
 
 	params, err := h.hooks.OnParsedRequest(ctx, r, request.Params)
 	if err != nil {
-		respondError(w, err)
+		RespondError(w, err)
 		return
 	}
 
@@ -112,25 +154,22 @@ func (h *readHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		defer cancel()
 	}
 
-	qry, err := h.engine.NewRangeQuery(
-		h.queryable,
-		params.Query,
-		params.Start,
-		params.End,
-		params.Step)
+	qry, err := h.newQueryFn(h.engine, h.queryable, params)
 	if err != nil {
-		h.logger.Error("error creating range query",
-			zap.Error(err), zap.String("query", params.Query))
-		respondError(w, err)
+		h.logger.Error("error creating query",
+			zap.Error(err), zap.String("query", params.Query),
+			zap.Bool("instant", h.opts.instant))
+		RespondError(w, err)
 		return
 	}
 	defer qry.Close()
 
 	res := qry.Exec(ctx)
 	if res.Err != nil {
-		h.logger.Error("error executing range query",
-			zap.Error(res.Err), zap.String("query", params.Query))
-		respondError(w, res.Err)
+		h.logger.Error("error executing query",
+			zap.Error(res.Err), zap.String("query", params.Query),
+			zap.Bool("instant", h.opts.instant))
+		RespondError(w, res.Err)
 		return
 	}
 
@@ -142,11 +181,12 @@ func (h *readHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	err = ApplyRangeWarnings(query, &resultMetadata)
 	if err != nil {
 		h.logger.Warn("error applying range warnings",
-			zap.Error(err), zap.String("query", query))
+			zap.Error(err), zap.String("query", query),
+			zap.Bool("instant", h.opts.instant))
 	}
 
 	handleroptions.AddWarningHeaders(w, resultMetadata)
-	respond(w, &queryData{
+	Respond(w, &QueryData{
 		Result:     res.Value,
 		ResultType: res.Value.Type(),
 	}, res.Warnings)

src/query/api/v1/handler/prom/read_test.go

@@ -36,6 +36,7 @@ import (
 	"github.com/m3db/m3/src/query/executor"
 	xerrors "github.com/m3db/m3/src/x/errors"
 	"github.com/m3db/m3/src/x/instrument"
+
 	"github.com/prometheus/prometheus/pkg/labels"
 	promstorage "github.com/prometheus/prometheus/storage"
 	"github.com/stretchr/testify/require"
@@ -78,7 +79,8 @@ func setupTest(_ *testing.T) testHandlers {
 		SetTimeoutOpts(timeoutOpts)
 	queryable := &mockQueryable{}
 	readHandler := newReadHandler(opts, hOpts, &noopReadHandlerHooks{}, queryable)
-	readInstantHandler := newReadInstantHandler(opts, hOpts, queryable)
+	readInstantHandler := newReadHandler(opts.WithInstant(true), hOpts,
+		&noopReadHandlerHooks{}, queryable)
 	return testHandlers{
 		queryable:          queryable,
 		readHandler:        readHandler,

src/query/api/v1/httpd/handler.go

@@ -179,7 +179,7 @@ func (h *Handler) RegisterRoutes() error {
 		PromQLEngine: h.options.PrometheusEngine(),
 	}
 	promqlQueryHandler := wrapped(prom.NewReadHandler(opts, nativeSourceOpts))
-	promqlInstantQueryHandler := wrapped(prom.NewReadInstantHandler(opts, nativeSourceOpts))
+	promqlInstantQueryHandler := wrapped(prom.NewReadHandler(opts.WithInstant(true), nativeSourceOpts))
 	nativePromReadHandler := wrapped(native.NewPromReadHandler(nativeSourceOpts))
 	nativePromReadInstantHandler := wrapped(native.NewPromReadInstantHandler(nativeSourceOpts))