feat: add resource tags to ListErrors API (SigNoz#2487)

makeavish · web-flow · commit 9d20c2f78707 · 2023-03-28T00:15:15.000+05:30
diff --git a/pkg/query-service/app/clickhouseReader/reader.go b/pkg/query-service/app/clickhouseReader/reader.go
@@ -1464,13 +1464,13 @@ func createTagQueryFromTagQueryParams(queryParams []model.TagQueryParam) []model
 	tags := []model.TagQuery{}
 	for _, tag := range queryParams {
 		if len(tag.StringValues) > 0 {
-			tags = append(tags, model.NewTagQueryString(tag.Key, tag.StringValues, tag.Operator))
+			tags = append(tags, model.NewTagQueryString(tag))
 		}
 		if len(tag.NumberValues) > 0 {
-			tags = append(tags, model.NewTagQueryNumber(tag.Key, tag.NumberValues, tag.Operator))
+			tags = append(tags, model.NewTagQueryNumber(tag))
 		}
 		if len(tag.BoolValues) > 0 {
-			tags = append(tags, model.NewTagQueryBool(tag.Key, tag.BoolValues, tag.Operator))
+			tags = append(tags, model.NewTagQueryBool(tag))
 		}
 	}
 	return tags
@@ -1494,18 +1494,7 @@ func buildQueryWithTagParams(ctx context.Context, tags []model.TagQuery) (string
 	for _, item := range tags {
 		var subQuery string
 		var argsSubQuery []interface{}
-		tagMapType := ""
-		switch item.(type) {
-		case model.TagQueryString:
-			tagMapType = constants.StringTagMapCol
-		case model.TagQueryNumber:
-			tagMapType = constants.NumberTagMapCol
-		case model.TagQueryBool:
-			tagMapType = constants.BoolTagMapCol
-		default:
-			// type not supported error
-			return "", nil, &model.ApiError{Typ: model.ErrorBadData, Err: fmt.Errorf("type not supported")}
-		}
+		tagMapType := item.GetTagMapColumn()
 		switch item.GetOperator() {
 		case model.EqualOperator:
 			subQuery, argsSubQuery = addArithmeticOperator(item, tagMapType, "=")
@@ -2698,6 +2687,17 @@ func (r *ClickHouseReader) ListErrors(ctx context.Context, queryParams *model.Li
 		query = query + " AND exceptionType ilike @exceptionType"
 		args = append(args, clickhouse.Named("exceptionType", "%"+queryParams.ExceptionType+"%"))
 	}
+
+	// create TagQuery from TagQueryParams
+	tags := createTagQueryFromTagQueryParams(queryParams.Tags)
+	subQuery, argsSubQuery, errStatus := buildQueryWithTagParams(ctx, tags)
+	query += subQuery
+	args = append(args, argsSubQuery...)
+
+	if errStatus != nil {
+		zap.S().Error("Error in processing tags: ", errStatus)
+		return nil, errStatus
+	}
 	query = query + " GROUP BY groupID"
 	if len(queryParams.ServiceName) != 0 {
 		query = query + ", serviceName"
@@ -2747,6 +2747,18 @@ func (r *ClickHouseReader) CountErrors(ctx context.Context, queryParams *model.C
 		query = query + " AND exceptionType ilike @exceptionType"
 		args = append(args, clickhouse.Named("exceptionType", "%"+queryParams.ExceptionType+"%"))
 	}
+
+	// create TagQuery from TagQueryParams
+	tags := createTagQueryFromTagQueryParams(queryParams.Tags)
+	subQuery, argsSubQuery, errStatus := buildQueryWithTagParams(ctx, tags)
+	query += subQuery
+	args = append(args, argsSubQuery...)
+
+	if errStatus != nil {
+		zap.S().Error("Error in processing tags: ", errStatus)
+		return 0, errStatus
+	}
+
 	err := r.db.QueryRow(ctx, query, args...).Scan(&errorCount)
 	zap.S().Info(query)
 
diff --git a/pkg/query-service/app/http_handler.go b/pkg/query-service/app/http_handler.go
@@ -328,8 +328,8 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *AuthMiddleware) {
 	router.HandleFunc("/api/v1/getFilteredSpans/aggregates", am.ViewAccess(aH.getFilteredSpanAggregates)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/getTagValues", am.ViewAccess(aH.getTagValues)).Methods(http.MethodPost)
 
-	router.HandleFunc("/api/v1/listErrors", am.ViewAccess(aH.listErrors)).Methods(http.MethodGet)
-	router.HandleFunc("/api/v1/countErrors", am.ViewAccess(aH.countErrors)).Methods(http.MethodGet)
+	router.HandleFunc("/api/v1/listErrors", am.ViewAccess(aH.listErrors)).Methods(http.MethodPost)
+	router.HandleFunc("/api/v1/countErrors", am.ViewAccess(aH.countErrors)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v1/errorFromErrorID", am.ViewAccess(aH.getErrorFromErrorID)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/errorFromGroupID", am.ViewAccess(aH.getErrorFromGroupID)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/nextPrevErrorIDs", am.ViewAccess(aH.getNextPrevErrorIDs)).Methods(http.MethodGet)
diff --git a/pkg/query-service/app/parser.go b/pkg/query-service/app/parser.go
@@ -494,76 +494,54 @@ func parseListErrorsRequest(r *http.Request) (*model.ListErrorsParams, error) {
 	var allowedOrderParams = []string{"exceptionType", "exceptionCount", "firstSeen", "lastSeen", "serviceName"}
 	var allowedOrderDirections = []string{"ascending", "descending"}
 
-	startTime, err := parseTime("start", r)
+	var postData *model.ListErrorsParams
+	err := json.NewDecoder(r.Body).Decode(&postData)
+
 	if err != nil {
 		return nil, err
 	}
-	endTime, err := parseTimeMinusBuffer("end", r)
+
+	postData.Start, err = parseTimeStr(postData.StartStr, "start")
 	if err != nil {
 		return nil, err
 	}
-
-	order := r.URL.Query().Get("order")
-	if len(order) > 0 && !DoesExistInSlice(order, allowedOrderDirections) {
-		return nil, errors.New(fmt.Sprintf("given order: %s is not allowed in query", order))
-	}
-	orderParam := r.URL.Query().Get("orderParam")
-	if len(order) > 0 && !DoesExistInSlice(orderParam, allowedOrderParams) {
-		return nil, errors.New(fmt.Sprintf("given orderParam: %s is not allowed in query", orderParam))
+	postData.End, err = parseTimeMinusBufferStr(postData.EndStr, "end")
+	if err != nil {
+		return nil, err
 	}
-	limit := r.URL.Query().Get("limit")
-	offset := r.URL.Query().Get("offset")
-
-	if len(offset) == 0 || len(limit) == 0 {
-		return nil, fmt.Errorf("offset or limit param cannot be empty from the query")
+	if postData.Limit == 0 {
+		return nil, fmt.Errorf("limit param cannot be empty from the query")
 	}
 
-	limitInt, err := strconv.Atoi(limit)
-	if err != nil {
-		return nil, errors.New("limit param is not in correct format")
-	}
-	offsetInt, err := strconv.Atoi(offset)
-	if err != nil {
-		return nil, errors.New("offset param is not in correct format")
+	if len(postData.Order) > 0 && !DoesExistInSlice(postData.Order, allowedOrderDirections) {
+		return nil, errors.New(fmt.Sprintf("given order: %s is not allowed in query", postData.Order))
 	}
-	serviceName := r.URL.Query().Get("serviceName")
-	exceptionType := r.URL.Query().Get("exceptionType")
 
-	params := &model.ListErrorsParams{
-		Start:         startTime,
-		End:           endTime,
-		OrderParam:    orderParam,
-		Order:         order,
-		Limit:         int64(limitInt),
-		Offset:        int64(offsetInt),
-		ServiceName:   serviceName,
-		ExceptionType: exceptionType,
+	if len(postData.Order) > 0 && !DoesExistInSlice(postData.OrderParam, allowedOrderParams) {
+		return nil, errors.New(fmt.Sprintf("given orderParam: %s is not allowed in query", postData.OrderParam))
 	}
 
-	return params, nil
+	return postData, nil
 }
 
 func parseCountErrorsRequest(r *http.Request) (*model.CountErrorsParams, error) {
 
-	startTime, err := parseTime("start", r)
+	var postData *model.CountErrorsParams
+	err := json.NewDecoder(r.Body).Decode(&postData)
+
 	if err != nil {
 		return nil, err
 	}
-	endTime, err := parseTimeMinusBuffer("end", r)
+
+	postData.Start, err = parseTimeStr(postData.StartStr, "start")
 	if err != nil {
 		return nil, err
 	}
-	serviceName := r.URL.Query().Get("serviceName")
-	exceptionType := r.URL.Query().Get("exceptionType")
-
-	params := &model.CountErrorsParams{
-		Start:         startTime,
-		End:           endTime,
-		ServiceName:   serviceName,
-		ExceptionType: exceptionType,
+	postData.End, err = parseTimeMinusBufferStr(postData.EndStr, "end")
+	if err != nil {
+		return nil, err
 	}
-
-	return params, nil
+	return postData, nil
 }
 
 func parseGetErrorRequest(r *http.Request) (*model.GetErrorParams, error) {
diff --git a/pkg/query-service/constants/constants.go b/pkg/query-service/constants/constants.go
@@ -219,11 +219,5 @@ var ReservedColumnTargetAliases = map[string]struct{}{
 	"value":  {},
 }
 
-const (
-	StringTagMapCol = "stringTagMap"
-	NumberTagMapCol = "numberTagMap"
-	BoolTagMapCol   = "boolTagMap"
-)
-
 // logsPPLPfx is a short constant for logsPipelinePrefix
 const LogsPPLPfx = "logstransform/pipeline_"
diff --git a/pkg/query-service/model/queryParams.go b/pkg/query-service/model/queryParams.go
