time param on endpoint should be optional

Author: alanprot

pkg/cortex/modules.go

@@ -459,7 +459,7 @@ func (t *Cortex) initQueryFrontendTripperware() (serv services.Service, err erro
 		queryRangeMiddlewares,
 		instantQueryMiddlewares,
 		queryrange.PrometheusCodec,
-		instantquery.InstantQueryCodec,
+		instantquery.Codec,
 	)
 
 	return services.NewIdleService(nil, func(_ error) error {

pkg/querier/tripperware/instantquery/instant_query.go

@@ -8,11 +8,14 @@ import (
 	"net/http"
 	"net/url"
 	"sort"
+	"strconv"
 	"strings"
+	"time"
 
 	jsoniter "github.com/json-iterator/go"
 	"github.com/opentracing/opentracing-go"
 	otlog "github.com/opentracing/opentracing-go/log"
+	"github.com/pkg/errors"
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/model/timestamp"
 	"github.com/weaveworks/common/httpgrpc"
@@ -26,8 +29,8 @@ import (
 )
 
 var (
-	InstantQueryCodec tripperware.Codec = instantQueryCodec{}
-	json                                = jsoniter.Config{
+	Codec tripperware.Codec = newInstantQueryCodec()
+	json                    = jsoniter.Config{
 		EscapeHTML:             false, // No HTML in our responses.
 		SortMapKeys:            true,
 		ValidateJsonRawMessage: true,
@@ -102,6 +105,11 @@ func (r *PrometheusRequest) WithStats(stats string) tripperware.Request {
 
 type instantQueryCodec struct {
 	tripperware.Codec
+	now func() time.Time
+}
+
+func newInstantQueryCodec() instantQueryCodec {
+	return instantQueryCodec{now: time.Now}
 }
 
 func (resp *PrometheusInstantQueryResponse) HTTPHeaders() map[string][]string {
@@ -118,10 +126,10 @@ func (resp *PrometheusInstantQueryResponse) HTTPHeaders() map[string][]string {
 	return nil
 }
 
-func (instantQueryCodec) DecodeRequest(_ context.Context, r *http.Request, forwardHeaders []string) (tripperware.Request, error) {
+func (c instantQueryCodec) DecodeRequest(_ context.Context, r *http.Request, forwardHeaders []string) (tripperware.Request, error) {
 	result := PrometheusRequest{Headers: map[string][]string{}}
 	var err error
-	result.Time, err = util.ParseTime(r.FormValue("time"))
+	result.Time, err = parseTimeParam(r, "time", c.now().Unix())
 	if err != nil {
 		return nil, decorateWithParamName(err, "time")
 	}
@@ -443,3 +451,15 @@ func (s *PrometheusInstantQueryData) MarshalJSON() ([]byte, error) {
 		return s.Result.GetRawBytes(), nil
 	}
 }
+
+func parseTimeParam(r *http.Request, paramName string, defaultValue int64) (int64, error) {
+	val := r.FormValue(paramName)
+	if val == "" {
+		val = strconv.FormatInt(defaultValue, 10)
+	}
+	result, err := util.ParseTime(val)
+	if err != nil {
+		return 0, errors.Wrapf(err, "Invalid time value for '%s'", paramName)
+	}
+	return result, nil
+}

pkg/querier/tripperware/instantquery/instant_query_middlewares.go

@@ -12,6 +12,6 @@ func Middlewares(
 ) ([]tripperware.Middleware, error) {
 	var m []tripperware.Middleware
 
-	m = append(m, tripperware.ShardByMiddleware(log, limits, InstantQueryCodec))
+	m = append(m, tripperware.ShardByMiddleware(log, limits, Codec))
 	return m, nil
 }

pkg/querier/tripperware/instantquery/instant_query_test.go

@@ -8,24 +8,30 @@ import (
 	"net/http"
 	"strconv"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/weaveworks/common/httpgrpc"
 	"github.com/weaveworks/common/user"
 
 	"github.com/cortexproject/cortex/pkg/querier/tripperware"
 )
 
 func TestRequest(t *testing.T) {
+	now := time.Now()
+	codec := instantQueryCodec{now: func() time.Time {
+		return now
+	}}
 
 	for _, tc := range []struct {
 		url         string
+		expectedUrl string
 		expected    tripperware.Request
 		expectedErr error
 	}{
 		{
-			url: "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&stats=all&time=1536673680",
+			url:         "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&stats=all&time=1536673680",
+			expectedUrl: "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&stats=all&time=1536673680",
 			expected: &PrometheusRequest{
 				Path:  "/api/v1/query",
 				Time:  1536673680 * 1e3,
@@ -37,7 +43,8 @@ func TestRequest(t *testing.T) {
 			},
 		},
 		{
-			url: "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&time=1536673680",
+			url:         "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&time=1536673680",
+			expectedUrl: "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&time=1536673680",
 			expected: &PrometheusRequest{
 				Path:  "/api/v1/query",
 				Time:  1536673680 * 1e3,
@@ -49,8 +56,17 @@ func TestRequest(t *testing.T) {
 			},
 		},
 		{
-			url:         "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&stats=all",
-			expectedErr: httpgrpc.Errorf(http.StatusBadRequest, "invalid parameter \"time\"; cannot parse \"\" to a valid timestamp"),
+			url:         "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29",
+			expectedUrl: fmt.Sprintf("%s%d", "/api/v1/query?query=sum%28container_memory_rss%29+by+%28namespace%29&time=", now.Unix()),
+			expected: &PrometheusRequest{
+				Path:  "/api/v1/query",
+				Time:  now.Unix() * 1e3,
+				Query: "sum(container_memory_rss) by (namespace)",
+				Stats: "",
+				Headers: map[string][]string{
+					"Test-Header": {"test"},
+				},
+			},
 		},
 	} {
 		t.Run(tc.url, func(t *testing.T) {
@@ -63,16 +79,16 @@ func TestRequest(t *testing.T) {
 			// Get a deep copy of the request with Context changed to ctx
 			r = r.Clone(ctx)
 
-			req, err := InstantQueryCodec.DecodeRequest(ctx, r, []string{"Test-Header"})
+			req, err := codec.DecodeRequest(ctx, r, []string{"Test-Header"})
 			if err != nil {
 				require.EqualValues(t, tc.expectedErr, err)
 				return
 			}
 			require.EqualValues(t, tc.expected, req)
 
-			rdash, err := InstantQueryCodec.EncodeRequest(context.Background(), req)
+			rdash, err := codec.EncodeRequest(context.Background(), req)
 			require.NoError(t, err)
-			require.EqualValues(t, tc.url, rdash.RequestURI)
+			require.EqualValues(t, tc.expectedUrl, rdash.RequestURI)
 		})
 	}
 }
@@ -106,7 +122,7 @@ func TestResponse(t *testing.T) {
 				Header:     http.Header{"Content-Type": []string{"application/json"}},
 				Body:       io.NopCloser(bytes.NewBuffer([]byte(tc.body))),
 			}
-			resp, err := InstantQueryCodec.DecodeResponse(context.Background(), response, nil)
+			resp, err := Codec.DecodeResponse(context.Background(), response, nil)
 			require.NoError(t, err)
 
 			// Reset response, as the above call will have consumed the body reader.
@@ -116,7 +132,7 @@ func TestResponse(t *testing.T) {
 				Body:          io.NopCloser(bytes.NewBuffer([]byte(tc.body))),
 				ContentLength: int64(len(tc.body)),
 			}
-			resp2, err := InstantQueryCodec.EncodeResponse(context.Background(), resp)
+			resp2, err := Codec.EncodeResponse(context.Background(), resp)
 			require.NoError(t, err)
 			assert.Equal(t, response, resp2)
 		})
@@ -199,16 +215,16 @@ func TestMergeResponse(t *testing.T) {
 					Header:     http.Header{"Content-Type": []string{"application/json"}},
 					Body:       io.NopCloser(bytes.NewBuffer([]byte(r))),
 				}
-				dr, err := InstantQueryCodec.DecodeResponse(context.Background(), hr, nil)
+				dr, err := Codec.DecodeResponse(context.Background(), hr, nil)
 				require.NoError(t, err)
 				resps = append(resps, dr)
 			}
-			resp, err := InstantQueryCodec.MergeResponse(resps...)
+			resp, err := Codec.MergeResponse(resps...)
 			assert.Equal(t, err, tc.expectedErr)
 			if err != nil {
 				return
 			}
-			dr, err := InstantQueryCodec.EncodeResponse(context.Background(), resp)
+			dr, err := Codec.EncodeResponse(context.Background(), resp)
 			assert.Equal(t, err, tc.expectedErr)
 			contents, err := io.ReadAll(dr.Body)
 			assert.Equal(t, err, tc.expectedErr)

pkg/querier/tripperware/instantquery/shard_by_query_test.go

@@ -8,5 +8,5 @@ import (
 )
 
 func Test_shardQuery(t *testing.T) {
-	tripperware.TestQueryShardQuery(t, InstantQueryCodec, queryrange.ShardedPrometheusCodec)
+	tripperware.TestQueryShardQuery(t, Codec, queryrange.ShardedPrometheusCodec)
 }