Merge branch 'develop' into error-response

ee/query-service/app/api/auth.go

@@ -35,14 +35,14 @@ func (ah *APIHandler) loginUser(w http.ResponseWriter, r *http.Request) {
 	req := basemodel.LoginRequest{}
 	err := parseRequest(r, &req)
 	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
 	ctx := context.Background()
 
 	if req.Email != "" && ah.CheckFeature(model.SSO) {
-		var apierr basemodel.BaseApiError
+		var apierr *basemodel.ApiError
 		_, apierr = ah.AppDao().CanUsePassword(ctx, req.Email)
 		if apierr != nil && !apierr.IsNil() {
 			RespondError(w, apierr, nil)
@@ -74,7 +74,7 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 	requestBody, err := io.ReadAll(r.Body)
 	if err != nil {
 		zap.L().Error("received no input in api", zap.Error(err))
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
@@ -82,7 +82,7 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 
 	if err != nil {
 		zap.L().Error("received invalid user registration request", zap.Error(err))
-		RespondError(w, model.BadRequest(fmt.Errorf("failed to register user")), nil)
+		RespondError(w, basemodel.BadRequest(fmt.Errorf("failed to register user")), nil)
 		return
 	}
 
@@ -90,13 +90,13 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 	invite, err := baseauth.ValidateInvite(ctx, req)
 	if err != nil {
 		zap.L().Error("failed to validate invite token", zap.Error(err))
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
 	if invite == nil {
 		zap.L().Error("failed to validate invite token: it is either empty or invalid", zap.Error(err))
-		RespondError(w, model.BadRequest(basemodel.ErrSignupFailed{}), nil)
+		RespondError(w, basemodel.BadRequest(basemodel.ErrSignupFailed{}), nil)
 		return
 	}
 
@@ -104,7 +104,7 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 	domain, apierr := ah.AppDao().GetDomainByEmail(ctx, invite.Email)
 	if apierr != nil {
 		zap.L().Error("failed to get domain from email", zap.Error(apierr))
-		RespondError(w, model.InternalError(basemodel.ErrSignupFailed{}), nil)
+		RespondError(w, basemodel.InternalError(basemodel.ErrSignupFailed{}), nil)
 	}
 
 	precheckResp := &basemodel.PrecheckResponse{
@@ -120,7 +120,7 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		var precheckError basemodel.BaseApiError
+		var precheckError *basemodel.ApiError
 
 		precheckResp, precheckError = ah.AppDao().PrecheckLogin(ctx, user.Email, req.SourceUrl)
 		if precheckError != nil {
@@ -130,7 +130,7 @@ func (ah *APIHandler) registerUser(w http.ResponseWriter, r *http.Request) {
 	} else {
 		// no-sso, validate password
 		if err := baseauth.ValidatePassword(req.Password); err != nil {
-			RespondError(w, model.InternalError(fmt.Errorf("password is not in a valid format")), nil)
+			RespondError(w, basemodel.InternalError(fmt.Errorf("password is not in a valid format")), nil)
 			return
 		}
 
@@ -155,7 +155,7 @@ func (ah *APIHandler) getInvite(w http.ResponseWriter, r *http.Request) {
 
 	inviteObject, err := baseauth.GetInvite(context.Background(), token)
 	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 

ee/query-service/app/api/domains.go

@@ -9,6 +9,7 @@ import (
 	"github.com/google/uuid"
 	"github.com/gorilla/mux"
 	"go.signoz.io/signoz/ee/query-service/model"
+	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 )
 
 func (ah *APIHandler) listDomainsByOrg(w http.ResponseWriter, r *http.Request) {
@@ -27,12 +28,12 @@ func (ah *APIHandler) postDomain(w http.ResponseWriter, r *http.Request) {
 	req := model.OrgDomain{}
 
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
 	if err := req.ValidNew(); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
@@ -50,18 +51,18 @@ func (ah *APIHandler) putDomain(w http.ResponseWriter, r *http.Request) {
 	domainIdStr := mux.Vars(r)["id"]
 	domainId, err := uuid.Parse(domainIdStr)
 	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
 	req := model.OrgDomain{Id: domainId}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 	req.Id = domainId
 	if err := req.Valid(nil); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 	}
 
 	if apierr := ah.AppDao().UpdateDomain(ctx, &req); apierr != nil {
@@ -77,7 +78,7 @@ func (ah *APIHandler) deleteDomain(w http.ResponseWriter, r *http.Request) {
 
 	domainId, err := uuid.Parse(domainIdStr)
 	if err != nil {
-		RespondError(w, model.BadRequest(fmt.Errorf("invalid domain id")), nil)
+		RespondError(w, basemodel.BadRequest(fmt.Errorf("invalid domain id")), nil)
 		return
 	}
 

ee/query-service/app/api/license.go

@@ -9,6 +9,7 @@ import (
 
 	"go.signoz.io/signoz/ee/query-service/constants"
 	"go.signoz.io/signoz/ee/query-service/model"
+	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 	"go.uber.org/zap"
 )
 
@@ -71,12 +72,12 @@ func (ah *APIHandler) applyLicense(w http.ResponseWriter, r *http.Request) {
 	var l model.License
 
 	if err := json.NewDecoder(r.Body).Decode(&l); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
 	if l.Key == "" {
-		RespondError(w, model.BadRequest(fmt.Errorf("license key is required")), nil)
+		RespondError(w, basemodel.BadRequest(fmt.Errorf("license key is required")), nil)
 		return
 	}
 	license, apiError := ah.LM().Activate(r.Context(), l.Key)
@@ -100,20 +101,20 @@ func (ah *APIHandler) checkout(w http.ResponseWriter, r *http.Request) {
 	hClient := &http.Client{}
 	req, err := http.NewRequest("POST", constants.LicenseSignozIo+"/checkout", r.Body)
 	if err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 	req.Header.Add("X-SigNoz-SecretKey", constants.LicenseAPIKey)
 	licenseResp, err := hClient.Do(req)
 	if err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 
 	// decode response body
 	var resp checkoutResponse
 	if err := json.NewDecoder(licenseResp.Body).Decode(&resp); err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 
@@ -124,7 +125,7 @@ func (ah *APIHandler) getBilling(w http.ResponseWriter, r *http.Request) {
 	licenseKey := r.URL.Query().Get("licenseKey")
 
 	if licenseKey == "" {
-		RespondError(w, model.BadRequest(fmt.Errorf("license key is required")), nil)
+		RespondError(w, basemodel.BadRequest(fmt.Errorf("license key is required")), nil)
 		return
 	}
 
@@ -133,20 +134,20 @@ func (ah *APIHandler) getBilling(w http.ResponseWriter, r *http.Request) {
 	hClient := &http.Client{}
 	req, err := http.NewRequest("GET", billingURL, nil)
 	if err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 	req.Header.Add("X-SigNoz-SecretKey", constants.LicenseAPIKey)
 	billingResp, err := hClient.Do(req)
 	if err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 
 	// decode response body
 	var billingResponse billingDetails
 	if err := json.NewDecoder(billingResp.Body).Decode(&billingResponse); err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 
@@ -251,20 +252,20 @@ func (ah *APIHandler) portalSession(w http.ResponseWriter, r *http.Request) {
 	hClient := &http.Client{}
 	req, err := http.NewRequest("POST", constants.LicenseSignozIo+"/portal", r.Body)
 	if err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 	req.Header.Add("X-SigNoz-SecretKey", constants.LicenseAPIKey)
 	licenseResp, err := hClient.Do(req)
 	if err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 
 	// decode response body
 	var resp checkoutResponse
 	if err := json.NewDecoder(licenseResp.Body).Decode(&resp); err != nil {
-		RespondError(w, model.InternalError(err), nil)
+		RespondError(w, basemodel.InternalError(err), nil)
 		return
 	}
 

ee/query-service/app/api/pat.go

@@ -31,13 +31,13 @@ func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
 
 	req := model.CreatePATRequestBody{}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 	user, err := auth.GetUserFromRequest(r)
 	if err != nil {
-		RespondError(w, &model.ApiError{
+		RespondError(w, &basemodel.ApiError{
-			Typ: model.ErrorUnauthorized,
+			Typ: basemodel.ErrorUnauthorized,
 			Err: err,
 		}, nil)
 		return
@@ -49,7 +49,7 @@ func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
 	}
 	err = validatePATRequest(pat)
 	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
@@ -66,7 +66,7 @@ func (ah *APIHandler) createPAT(w http.ResponseWriter, r *http.Request) {
 	}
 
 	zap.L().Info("Got Create PAT request", zap.Any("pat", pat))
-	var apierr basemodel.BaseApiError
+	var apierr *basemodel.ApiError
 	if pat, apierr = ah.AppDao().CreatePAT(ctx, pat); apierr != nil {
 		RespondError(w, apierr, nil)
 		return
@@ -93,14 +93,14 @@ func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
 
 	req := model.PAT{}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
 	user, err := auth.GetUserFromRequest(r)
 	if err != nil {
-		RespondError(w, &model.ApiError{
+		RespondError(w, &basemodel.ApiError{
-			Typ: model.ErrorUnauthorized,
+			Typ: basemodel.ErrorUnauthorized,
 			Err: err,
 		}, nil)
 		return
@@ -108,7 +108,7 @@ func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
 
 	err = validatePATRequest(req)
 	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
+		RespondError(w, basemodel.BadRequest(err), nil)
 		return
 	}
 
@@ -116,7 +116,7 @@ func (ah *APIHandler) updatePAT(w http.ResponseWriter, r *http.Request) {
 	id := mux.Vars(r)["id"]
 	req.UpdatedAt = time.Now().Unix()
 	zap.L().Info("Got Update PAT request", zap.Any("pat", req))
-	var apierr basemodel.BaseApiError
+	var apierr *basemodel.ApiError
 	if apierr = ah.AppDao().UpdatePAT(ctx, req, id); apierr != nil {
 		RespondError(w, apierr, nil)
 		return
@@ -129,8 +129,8 @@ func (ah *APIHandler) getPATs(w http.ResponseWriter, r *http.Request) {
 	ctx := context.Background()
 	user, err := auth.GetUserFromRequest(r)
 	if err != nil {
-		RespondError(w, &model.ApiError{
+		RespondError(w, &basemodel.ApiError{
-			Typ: model.ErrorUnauthorized,
+			Typ: basemodel.ErrorUnauthorized,
 			Err: err,
 		}, nil)
 		return
@@ -149,8 +149,8 @@ func (ah *APIHandler) revokePAT(w http.ResponseWriter, r *http.Request) {
 	id := mux.Vars(r)["id"]
 	user, err := auth.GetUserFromRequest(r)
 	if err != nil {
-		RespondError(w, &model.ApiError{
+		RespondError(w, &basemodel.ApiError{
-			Typ: model.ErrorUnauthorized,
+			Typ: basemodel.ErrorUnauthorized,
 			Err: err,
 		}, nil)
 		return

ee/query-service/app/api/response.go

@@ -7,6 +7,6 @@ import (
 	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 )
 
-func RespondError(w http.ResponseWriter, apiErr basemodel.BaseApiError, data interface{}) {
+func RespondError(w http.ResponseWriter, apiErr *basemodel.ApiError, data interface{}) {
-	baseapp.RespondError(w, apiErr, data)
+	baseapp.RespondError(w, apiErr)
 }

ee/query-service/app/api/traces.go

@@ -4,7 +4,6 @@ import (
 	"net/http"
 
 	"go.signoz.io/signoz/ee/query-service/app/db"
-	"go.signoz.io/signoz/ee/query-service/model"
 	baseapp "go.signoz.io/signoz/pkg/query-service/app"
 	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 	"go.uber.org/zap"
@@ -19,7 +18,7 @@ func (ah *APIHandler) searchTraces(w http.ResponseWriter, r *http.Request) {
 	}
 	searchTracesParams, err := baseapp.ParseSearchTracesParams(r)
 	if err != nil {
-		RespondError(w, &model.ApiError{Typ: model.ErrorBadData, Err: err}, "Error reading params")
+		RespondError(w, &basemodel.ApiError{Typ: basemodel.ErrorBadData, Err: err}, "Error reading params")
 		return
 	}
 

ee/query-service/dao/interface.go

@@ -21,24 +21,24 @@ type ModelDao interface {
 	DB() *sqlx.DB
 
 	// auth methods
-	CanUsePassword(ctx context.Context, email string) (bool, basemodel.BaseApiError)
+	CanUsePassword(ctx context.Context, email string) (bool, *basemodel.ApiError)
-	PrepareSsoRedirect(ctx context.Context, redirectUri, email string) (redirectURL string, apierr basemodel.BaseApiError)
+	PrepareSsoRedirect(ctx context.Context, redirectUri, email string) (redirectURL string, apierr *basemodel.ApiError)
 	GetDomainFromSsoResponse(ctx context.Context, relayState *url.URL) (*model.OrgDomain, error)
 
 	// org domain (auth domains) CRUD ops
-	ListDomains(ctx context.Context, orgId string) ([]model.OrgDomain, basemodel.BaseApiError)
+	ListDomains(ctx context.Context, orgId string) ([]model.OrgDomain, *basemodel.ApiError)
-	GetDomain(ctx context.Context, id uuid.UUID) (*model.OrgDomain, basemodel.BaseApiError)
+	GetDomain(ctx context.Context, id uuid.UUID) (*model.OrgDomain, *basemodel.ApiError)
-	CreateDomain(ctx context.Context, d *model.OrgDomain) basemodel.BaseApiError
+	CreateDomain(ctx context.Context, d *model.OrgDomain) *basemodel.ApiError
-	UpdateDomain(ctx context.Context, domain *model.OrgDomain) basemodel.BaseApiError
+	UpdateDomain(ctx context.Context, domain *model.OrgDomain) *basemodel.ApiError
-	DeleteDomain(ctx context.Context, id uuid.UUID) basemodel.BaseApiError
+	DeleteDomain(ctx context.Context, id uuid.UUID) *basemodel.ApiError
-	GetDomainByEmail(ctx context.Context, email string) (*model.OrgDomain, basemodel.BaseApiError)
+	GetDomainByEmail(ctx context.Context, email string) (*model.OrgDomain, *basemodel.ApiError)
 
-	CreatePAT(ctx context.Context, p model.PAT) (model.PAT, basemodel.BaseApiError)
+	CreatePAT(ctx context.Context, p model.PAT) (model.PAT, *basemodel.ApiError)
-	UpdatePAT(ctx context.Context, p model.PAT, id string) basemodel.BaseApiError
+	UpdatePAT(ctx context.Context, p model.PAT, id string) *basemodel.ApiError
-	GetPAT(ctx context.Context, pat string) (*model.PAT, basemodel.BaseApiError)
+	GetPAT(ctx context.Context, pat string) (*model.PAT, *basemodel.ApiError)
-	UpdatePATLastUsed(ctx context.Context, pat string, lastUsed int64) basemodel.BaseApiError
+	UpdatePATLastUsed(ctx context.Context, pat string, lastUsed int64) *basemodel.ApiError
-	GetPATByID(ctx context.Context, id string) (*model.PAT, basemodel.BaseApiError)
+	GetPATByID(ctx context.Context, id string) (*model.PAT, *basemodel.ApiError)
-	GetUserByPAT(ctx context.Context, token string) (*basemodel.UserPayload, basemodel.BaseApiError)
+	GetUserByPAT(ctx context.Context, token string) (*basemodel.UserPayload, *basemodel.ApiError)
-	ListPATs(ctx context.Context) ([]model.PAT, basemodel.BaseApiError)
+	ListPATs(ctx context.Context) ([]model.PAT, *basemodel.ApiError)
-	RevokePAT(ctx context.Context, id string, userID string) basemodel.BaseApiError
+	RevokePAT(ctx context.Context, id string, userID string) *basemodel.ApiError
 }

ee/query-service/dao/sqlite/auth.go

@@ -17,19 +17,19 @@ import (
 	"go.uber.org/zap"
 )
 
-func (m *modelDao) createUserForSAMLRequest(ctx context.Context, email string) (*basemodel.User, basemodel.BaseApiError) {
+func (m *modelDao) createUserForSAMLRequest(ctx context.Context, email string) (*basemodel.User, *basemodel.ApiError) {
 	// get auth domain from email domain
 	domain, apierr := m.GetDomainByEmail(ctx, email)
 
 	if apierr != nil {
 		zap.L().Error("failed to get domain from email", zap.Error(apierr))
-		return nil, model.InternalErrorStr("failed to get domain from email")
+		return nil, basemodel.InternalError(fmt.Errorf("failed to get domain from email"))
 	}
 
 	hash, err := baseauth.PasswordHash(utils.GeneratePassowrd())
 	if err != nil {
 		zap.L().Error("failed to generate password hash when registering a user via SSO redirect", zap.Error(err))
-		return nil, model.InternalErrorStr("failed to generate password hash")
+		return nil, basemodel.InternalError(fmt.Errorf("failed to generate password hash"))
 	}
 
 	group, apiErr := m.GetGroupByName(ctx, baseconst.ViewerGroup)
@@ -61,12 +61,12 @@ func (m *modelDao) createUserForSAMLRequest(ctx context.Context, email string) (
 
 // PrepareSsoRedirect prepares redirect page link after SSO response
 // is successfully parsed (i.e. valid email is available)
-func (m *modelDao) PrepareSsoRedirect(ctx context.Context, redirectUri, email string) (redirectURL string, apierr basemodel.BaseApiError) {
+func (m *modelDao) PrepareSsoRedirect(ctx context.Context, redirectUri, email string) (redirectURL string, apierr *basemodel.ApiError) {
 
 	userPayload, apierr := m.GetUserByEmail(ctx, email)
 	if !apierr.IsNil() {
 		zap.L().Error("failed to get user with email received from auth provider", zap.String("error", apierr.Error()))
-		return "", model.BadRequestStr("invalid user email received from the auth provider")
+		return "", basemodel.BadRequest(fmt.Errorf("invalid user email received from the auth provider"))
 	}
 
 	user := &basemodel.User{}
@@ -85,7 +85,7 @@ func (m *modelDao) PrepareSsoRedirect(ctx context.Context, redirectUri, email st
 	tokenStore, err := baseauth.GenerateJWTForUser(user)
 	if err != nil {
 		zap.L().Error("failed to generate token for SSO login user", zap.Error(err))
-		return "", model.InternalErrorStr("failed to generate token for the user")
+		return "", basemodel.InternalError(fmt.Errorf("failed to generate token for the user"))
 	}
 
 	return fmt.Sprintf("%s?jwt=%s&usr=%s&refreshjwt=%s",
@@ -95,7 +95,7 @@ func (m *modelDao) PrepareSsoRedirect(ctx context.Context, redirectUri, email st
 		tokenStore.RefreshJwt), nil
 }
 
-func (m *modelDao) CanUsePassword(ctx context.Context, email string) (bool, basemodel.BaseApiError) {
+func (m *modelDao) CanUsePassword(ctx context.Context, email string) (bool, *basemodel.ApiError) {
 	domain, apierr := m.GetDomainByEmail(ctx, email)
 	if apierr != nil {
 		return false, apierr
@@ -110,7 +110,7 @@ func (m *modelDao) CanUsePassword(ctx context.Context, email string) (bool, base
 		}
 
 		if userPayload.Role != baseconst.AdminGroup {
-			return false, model.BadRequest(fmt.Errorf("auth method not supported"))
+			return false, basemodel.BadRequest(fmt.Errorf("auth method not supported"))
 		}
 
 	}
@@ -120,7 +120,7 @@ func (m *modelDao) CanUsePassword(ctx context.Context, email string) (bool, base
 
 // PrecheckLogin is called when the login or signup page is loaded
 // to check sso login is to be prompted
-func (m *modelDao) PrecheckLogin(ctx context.Context, email, sourceUrl string) (*basemodel.PrecheckResponse, basemodel.BaseApiError) {
+func (m *modelDao) PrecheckLogin(ctx context.Context, email, sourceUrl string) (*basemodel.PrecheckResponse, *basemodel.ApiError) {
 
 	// assume user is valid unless proven otherwise
 	resp := &basemodel.PrecheckResponse{IsUser: true, CanSelfRegister: false}
@@ -144,7 +144,7 @@ func (m *modelDao) PrecheckLogin(ctx context.Context, email, sourceUrl string) (
 			ssoAvailable = false
 		default:
 			zap.L().Error("feature check failed", zap.String("featureKey", model.SSO), zap.Error(err))
-			return resp, model.BadRequestStr(err.Error())
+			return resp, &basemodel.ApiError{Err: err, Typ: basemodel.ErrorBadData}
 		}
 	}
 
@@ -177,7 +177,7 @@ func (m *modelDao) PrecheckLogin(ctx context.Context, email, sourceUrl string) (
 			siteUrl, err := url.Parse(escapedUrl)
 			if err != nil {
 				zap.L().Error("failed to parse referer", zap.Error(err))
-				return resp, model.InternalError(fmt.Errorf("failed to generate login request"))
+				return resp, basemodel.InternalError(fmt.Errorf("failed to generate login request"))
 			}
 
 			// build Idp URL that will authenticat the user
@@ -186,7 +186,7 @@ func (m *modelDao) PrecheckLogin(ctx context.Context, email, sourceUrl string) (
 
 			if err != nil {
 				zap.L().Error("failed to prepare saml request for domain", zap.String("domain", orgDomain.Name), zap.Error(err))
-				return resp, model.InternalError(err)
+				return resp, basemodel.InternalError(err)
 			}
 
 			// set SSO to true, as the url is generated correctly

ee/query-service/dao/sqlite/domain.go

@@ -76,47 +76,47 @@ func (m *modelDao) GetDomainFromSsoResponse(ctx context.Context, relayState *url
 }
 
 // GetDomainByName returns org domain for a given domain name
-func (m *modelDao) GetDomainByName(ctx context.Context, name string) (*model.OrgDomain, basemodel.BaseApiError) {
+func (m *modelDao) GetDomainByName(ctx context.Context, name string) (*model.OrgDomain, *basemodel.ApiError) {
 
 	stored := StoredDomain{}
 	err := m.DB().Get(&stored, `SELECT * FROM org_domains WHERE name=$1 LIMIT 1`, name)
 
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.BadRequest(fmt.Errorf("invalid domain name"))
+			return nil, basemodel.BadRequest(fmt.Errorf("invalid domain name"))
 		}
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	domain := &model.OrgDomain{Id: stored.Id, Name: stored.Name, OrgId: stored.OrgId}
 	if err := domain.LoadConfig(stored.Data); err != nil {
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 	return domain, nil
 }
 
 // GetDomain returns org domain for a given domain id
-func (m *modelDao) GetDomain(ctx context.Context, id uuid.UUID) (*model.OrgDomain, basemodel.BaseApiError) {
+func (m *modelDao) GetDomain(ctx context.Context, id uuid.UUID) (*model.OrgDomain, *basemodel.ApiError) {
 
 	stored := StoredDomain{}
 	err := m.DB().Get(&stored, `SELECT * FROM org_domains WHERE id=$1 LIMIT 1`, id)
 
 	if err != nil {
 		if err == sql.ErrNoRows {
-			return nil, model.BadRequest(fmt.Errorf("invalid domain id"))
+			return nil, basemodel.BadRequest(fmt.Errorf("invalid domain id"))
 		}
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	domain := &model.OrgDomain{Id: stored.Id, Name: stored.Name, OrgId: stored.OrgId}
 	if err := domain.LoadConfig(stored.Data); err != nil {
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 	return domain, nil
 }
 
 // ListDomains gets the list of auth domains by org id
-func (m *modelDao) ListDomains(ctx context.Context, orgId string) ([]model.OrgDomain, basemodel.BaseApiError) {
+func (m *modelDao) ListDomains(ctx context.Context, orgId string) ([]model.OrgDomain, *basemodel.ApiError) {
 	domains := []model.OrgDomain{}
 
 	stored := []StoredDomain{}
@@ -126,7 +126,7 @@ func (m *modelDao) ListDomains(ctx context.Context, orgId string) ([]model.OrgDo
 		if err == sql.ErrNoRows {
 			return []model.OrgDomain{}, nil
 		}
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	for _, s := range stored {
@@ -141,20 +141,20 @@ func (m *modelDao) ListDomains(ctx context.Context, orgId string) ([]model.OrgDo
 }
 
 // CreateDomain creates  a new auth domain
-func (m *modelDao) CreateDomain(ctx context.Context, domain *model.OrgDomain) basemodel.BaseApiError {
+func (m *modelDao) CreateDomain(ctx context.Context, domain *model.OrgDomain) *basemodel.ApiError {
 
 	if domain.Id == uuid.Nil {
 		domain.Id = uuid.New()
 	}
 
 	if domain.OrgId == "" || domain.Name == "" {
-		return model.BadRequest(fmt.Errorf("domain creation failed, missing fields: OrgId, Name "))
+		return basemodel.BadRequest(fmt.Errorf("domain creation failed, missing fields: OrgId, Name "))
 	}
 
 	configJson, err := json.Marshal(domain)
 	if err != nil {
 		zap.L().Error("failed to unmarshal domain config", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain creation failed"))
+		return basemodel.InternalError(fmt.Errorf("domain creation failed"))
 	}
 
 	_, err = m.DB().ExecContext(ctx,
@@ -168,24 +168,24 @@ func (m *modelDao) CreateDomain(ctx context.Context, domain *model.OrgDomain) ba
 
 	if err != nil {
 		zap.L().Error("failed to insert domain in db", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain creation failed"))
+		return basemodel.InternalError(fmt.Errorf("domain creation failed"))
 	}
 
 	return nil
 }
 
 // UpdateDomain updates stored config params for a domain
-func (m *modelDao) UpdateDomain(ctx context.Context, domain *model.OrgDomain) basemodel.BaseApiError {
+func (m *modelDao) UpdateDomain(ctx context.Context, domain *model.OrgDomain) *basemodel.ApiError {
 
 	if domain.Id == uuid.Nil {
 		zap.L().Error("domain update failed", zap.Error(fmt.Errorf("OrgDomain.Id is null")))
-		return model.InternalError(fmt.Errorf("domain update failed"))
+		return basemodel.InternalError(fmt.Errorf("domain update failed"))
 	}
 
 	configJson, err := json.Marshal(domain)
 	if err != nil {
 		zap.L().Error("domain update failed", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain update failed"))
+		return basemodel.InternalError(fmt.Errorf("domain update failed"))
 	}
 
 	_, err = m.DB().ExecContext(ctx,
@@ -196,18 +196,18 @@ func (m *modelDao) UpdateDomain(ctx context.Context, domain *model.OrgDomain) ba
 
 	if err != nil {
 		zap.L().Error("domain update failed", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain update failed"))
+		return basemodel.InternalError(fmt.Errorf("domain update failed"))
 	}
 
 	return nil
 }
 
 // DeleteDomain deletes an org domain
-func (m *modelDao) DeleteDomain(ctx context.Context, id uuid.UUID) basemodel.BaseApiError {
+func (m *modelDao) DeleteDomain(ctx context.Context, id uuid.UUID) *basemodel.ApiError {
 
 	if id == uuid.Nil {
 		zap.L().Error("domain delete failed", zap.Error(fmt.Errorf("OrgDomain.Id is null")))
-		return model.InternalError(fmt.Errorf("domain delete failed"))
+		return basemodel.InternalError(fmt.Errorf("domain delete failed"))
 	}
 
 	_, err := m.DB().ExecContext(ctx,
@@ -216,21 +216,21 @@ func (m *modelDao) DeleteDomain(ctx context.Context, id uuid.UUID) basemodel.Bas
 
 	if err != nil {
 		zap.L().Error("domain delete failed", zap.Error(err))
-		return model.InternalError(fmt.Errorf("domain delete failed"))
+		return basemodel.InternalError(fmt.Errorf("domain delete failed"))
 	}
 
 	return nil
 }
 
-func (m *modelDao) GetDomainByEmail(ctx context.Context, email string) (*model.OrgDomain, basemodel.BaseApiError) {
+func (m *modelDao) GetDomainByEmail(ctx context.Context, email string) (*model.OrgDomain, *basemodel.ApiError) {
 
 	if email == "" {
-		return nil, model.BadRequest(fmt.Errorf("could not find auth domain, missing fields: email "))
+		return nil, basemodel.BadRequest(fmt.Errorf("could not find auth domain, missing fields: email "))
 	}
 
 	components := strings.Split(email, "@")
 	if len(components) < 2 {
-		return nil, model.BadRequest(fmt.Errorf("invalid email address"))
+		return nil, basemodel.BadRequest(fmt.Errorf("invalid email address"))
 	}
 
 	parsedDomain := components[1]
@@ -242,12 +242,12 @@ func (m *modelDao) GetDomainByEmail(ctx context.Context, email string) (*model.O
 		if err == sql.ErrNoRows {
 			return nil, nil
 		}
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	domain := &model.OrgDomain{Id: stored.Id, Name: stored.Name, OrgId: stored.OrgId}
 	if err := domain.LoadConfig(stored.Data); err != nil {
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 	return domain, nil
 }

ee/query-service/dao/sqlite/pat.go

@@ -11,7 +11,7 @@ import (
 	"go.uber.org/zap"
 )
 
-func (m *modelDao) CreatePAT(ctx context.Context, p model.PAT) (model.PAT, basemodel.BaseApiError) {
+func (m *modelDao) CreatePAT(ctx context.Context, p model.PAT) (model.PAT, *basemodel.ApiError) {
 	result, err := m.DB().ExecContext(ctx,
 		"INSERT INTO personal_access_tokens (user_id, token, role, name, created_at, expires_at, updated_at, updated_by_user_id, last_used, revoked) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)",
 		p.UserID,
@@ -27,12 +27,12 @@ func (m *modelDao) CreatePAT(ctx context.Context, p model.PAT) (model.PAT, basem
 	)
 	if err != nil {
 		zap.L().Error("Failed to insert PAT in db, err: %v", zap.Error(err))
-		return model.PAT{}, model.InternalError(fmt.Errorf("PAT insertion failed"))
+		return model.PAT{}, basemodel.InternalError(fmt.Errorf("PAT insertion failed"))
 	}
 	id, err := result.LastInsertId()
 	if err != nil {
 		zap.L().Error("Failed to get last inserted id, err: %v", zap.Error(err))
-		return model.PAT{}, model.InternalError(fmt.Errorf("PAT insertion failed"))
+		return model.PAT{}, basemodel.InternalError(fmt.Errorf("PAT insertion failed"))
 	}
 	p.Id = strconv.Itoa(int(id))
 	createdByUser, _ := m.GetUser(ctx, p.UserID)
@@ -53,7 +53,7 @@ func (m *modelDao) CreatePAT(ctx context.Context, p model.PAT) (model.PAT, basem
 	return p, nil
 }
 
-func (m *modelDao) UpdatePAT(ctx context.Context, p model.PAT, id string) basemodel.BaseApiError {
+func (m *modelDao) UpdatePAT(ctx context.Context, p model.PAT, id string) *basemodel.ApiError {
 	_, err := m.DB().ExecContext(ctx,
 		"UPDATE personal_access_tokens SET role=$1, name=$2, updated_at=$3, updated_by_user_id=$4 WHERE id=$5 and revoked=false;",
 		p.Role,
@@ -63,29 +63,29 @@ func (m *modelDao) UpdatePAT(ctx context.Context, p model.PAT, id string) basemo
 		id)
 	if err != nil {
 		zap.L().Error("Failed to update PAT in db, err: %v", zap.Error(err))
-		return model.InternalError(fmt.Errorf("PAT update failed"))
+		return basemodel.InternalError(fmt.Errorf("PAT update failed"))
 	}
 	return nil
 }
 
-func (m *modelDao) UpdatePATLastUsed(ctx context.Context, token string, lastUsed int64) basemodel.BaseApiError {
+func (m *modelDao) UpdatePATLastUsed(ctx context.Context, token string, lastUsed int64) *basemodel.ApiError {
 	_, err := m.DB().ExecContext(ctx,
 		"UPDATE personal_access_tokens SET last_used=$1 WHERE token=$2 and revoked=false;",
 		lastUsed,
 		token)
 	if err != nil {
 		zap.L().Error("Failed to update PAT last used in db, err: %v", zap.Error(err))
-		return model.InternalError(fmt.Errorf("PAT last used update failed"))
+		return basemodel.InternalError(fmt.Errorf("PAT last used update failed"))
 	}
 	return nil
 }
 
-func (m *modelDao) ListPATs(ctx context.Context) ([]model.PAT, basemodel.BaseApiError) {
+func (m *modelDao) ListPATs(ctx context.Context) ([]model.PAT, *basemodel.ApiError) {
 	pats := []model.PAT{}
 
 	if err := m.DB().Select(&pats, "SELECT * FROM personal_access_tokens WHERE revoked=false ORDER by updated_at DESC;"); err != nil {
 		zap.L().Error("Failed to fetch PATs err: %v", zap.Error(err))
-		return nil, model.InternalError(fmt.Errorf("failed to fetch PATs"))
+		return nil, basemodel.InternalError(fmt.Errorf("failed to fetch PATs"))
 	}
 	for i := range pats {
 		createdByUser, _ := m.GetUser(ctx, pats[i].UserID)
@@ -123,28 +123,28 @@ func (m *modelDao) ListPATs(ctx context.Context) ([]model.PAT, basemodel.BaseApi
 	return pats, nil
 }
 
-func (m *modelDao) RevokePAT(ctx context.Context, id string, userID string) basemodel.BaseApiError {
+func (m *modelDao) RevokePAT(ctx context.Context, id string, userID string) *basemodel.ApiError {
 	updatedAt := time.Now().Unix()
 	_, err := m.DB().ExecContext(ctx,
 		"UPDATE personal_access_tokens SET revoked=true, updated_by_user_id = $1, updated_at=$2 WHERE id=$3",
 		userID, updatedAt, id)
 	if err != nil {
 		zap.L().Error("Failed to revoke PAT in db, err: %v", zap.Error(err))
-		return model.InternalError(fmt.Errorf("PAT revoke failed"))
+		return basemodel.InternalError(fmt.Errorf("PAT revoke failed"))
 	}
 	return nil
 }
 
-func (m *modelDao) GetPAT(ctx context.Context, token string) (*model.PAT, basemodel.BaseApiError) {
+func (m *modelDao) GetPAT(ctx context.Context, token string) (*model.PAT, *basemodel.ApiError) {
 	pats := []model.PAT{}
 
 	if err := m.DB().Select(&pats, `SELECT * FROM personal_access_tokens WHERE token=? and revoked=false;`, token); err != nil {
-		return nil, model.InternalError(fmt.Errorf("failed to fetch PAT"))
+		return nil, basemodel.InternalError(fmt.Errorf("failed to fetch PAT"))
 	}
 
 	if len(pats) != 1 {
-		return nil, &model.ApiError{
+		return nil, &basemodel.ApiError{
-			Typ: model.ErrorInternal,
+			Typ: basemodel.ErrorInternal,
 			Err: fmt.Errorf("found zero or multiple PATs with same token, %s", token),
 		}
 	}
@@ -152,16 +152,16 @@ func (m *modelDao) GetPAT(ctx context.Context, token string) (*model.PAT, basemo
 	return &pats[0], nil
 }
 
-func (m *modelDao) GetPATByID(ctx context.Context, id string) (*model.PAT, basemodel.BaseApiError) {
+func (m *modelDao) GetPATByID(ctx context.Context, id string) (*model.PAT, *basemodel.ApiError) {
 	pats := []model.PAT{}
 
 	if err := m.DB().Select(&pats, `SELECT * FROM personal_access_tokens WHERE id=? and revoked=false;`, id); err != nil {
-		return nil, model.InternalError(fmt.Errorf("failed to fetch PAT"))
+		return nil, basemodel.InternalError(fmt.Errorf("failed to fetch PAT"))
 	}
 
 	if len(pats) != 1 {
-		return nil, &model.ApiError{
+		return nil, &basemodel.ApiError{
-			Typ: model.ErrorInternal,
+			Typ: basemodel.ErrorInternal,
 			Err: fmt.Errorf("found zero or multiple PATs with same token"),
 		}
 	}
@@ -170,7 +170,7 @@ func (m *modelDao) GetPATByID(ctx context.Context, id string) (*model.PAT, basem
 }
 
 // deprecated
-func (m *modelDao) GetUserByPAT(ctx context.Context, token string) (*basemodel.UserPayload, basemodel.BaseApiError) {
+func (m *modelDao) GetUserByPAT(ctx context.Context, token string) (*basemodel.UserPayload, *basemodel.ApiError) {
 	users := []basemodel.UserPayload{}
 
 	query := `SELECT
@@ -186,12 +186,12 @@ func (m *modelDao) GetUserByPAT(ctx context.Context, token string) (*basemodel.U
 			  WHERE u.id = p.user_id and p.token=? and p.expires_at >= strftime('%s', 'now');`
 
 	if err := m.DB().Select(&users, query, token); err != nil {
-		return nil, model.InternalError(fmt.Errorf("failed to fetch user from PAT, err: %v", err))
+		return nil, basemodel.InternalError(fmt.Errorf("failed to fetch user from PAT, err: %v", err))
 	}
 
 	if len(users) != 1 {
-		return nil, &model.ApiError{
+		return nil, &basemodel.ApiError{
-			Typ: model.ErrorInternal,
+			Typ: basemodel.ErrorInternal,
 			Err: fmt.Errorf("found zero or multiple users with same PAT token"),
 		}
 	}

ee/query-service/integrations/signozio/signozio.go

@@ -13,6 +13,7 @@ import (
 
 	"go.signoz.io/signoz/ee/query-service/constants"
 	"go.signoz.io/signoz/ee/query-service/model"
+	basemodel "go.signoz.io/signoz/pkg/query-service/model"
 )
 
 var C *Client
@@ -37,7 +38,7 @@ func init() {
 }
 
 // ActivateLicense sends key to license.signoz.io and gets activation data
-func ActivateLicense(key, siteId string) (*ActivationResponse, *model.ApiError) {
+func ActivateLicense(key, siteId string) (*ActivationResponse, *basemodel.ApiError) {
 	licenseReq := map[string]string{
 		"key":    key,
 		"siteId": siteId,
@@ -48,13 +49,13 @@ func ActivateLicense(key, siteId string) (*ActivationResponse, *model.ApiError)
 
 	if err != nil {
 		zap.L().Error("failed to connect to license.signoz.io", zap.Error(err))
-		return nil, model.BadRequest(fmt.Errorf("unable to connect with license.signoz.io, please check your network connection"))
+		return nil, basemodel.BadRequest(fmt.Errorf("unable to connect with license.signoz.io, please check your network connection"))
 	}
 
 	httpBody, err := io.ReadAll(httpResponse.Body)
 	if err != nil {
 		zap.L().Error("failed to read activation response from license.signoz.io", zap.Error(err))
-		return nil, model.BadRequest(fmt.Errorf("failed to read activation response from license.signoz.io"))
+		return nil, basemodel.BadRequest(fmt.Errorf("failed to read activation response from license.signoz.io"))
 	}
 
 	defer httpResponse.Body.Close()
@@ -64,22 +65,22 @@ func ActivateLicense(key, siteId string) (*ActivationResponse, *model.ApiError)
 	err = json.Unmarshal(httpBody, &result)
 	if err != nil {
 		zap.L().Error("failed to marshal activation response from license.signoz.io", zap.Error(err))
-		return nil, model.InternalError(errors.Wrap(err, "failed to marshal license activation response"))
+		return nil, basemodel.InternalError(errors.Wrap(err, "failed to marshal license activation response"))
 	}
 
 	switch httpResponse.StatusCode {
 	case 200, 201:
 		return result.Data, nil
 	case 400, 401:
-		return nil, model.BadRequest(fmt.Errorf(fmt.Sprintf("failed to activate: %s", result.Error)))
+		return nil, basemodel.BadRequest(fmt.Errorf(fmt.Sprintf("failed to activate: %s", result.Error)))
 	default:
-		return nil, model.InternalError(fmt.Errorf(fmt.Sprintf("failed to activate: %s", result.Error)))
+		return nil, basemodel.InternalError(fmt.Errorf(fmt.Sprintf("failed to activate: %s", result.Error)))
 	}
 
 }
 
 // ValidateLicense validates the license key
-func ValidateLicense(activationId string) (*ActivationResponse, *model.ApiError) {
+func ValidateLicense(activationId string) (*ActivationResponse, *basemodel.ApiError) {
 	validReq := map[string]string{
 		"activationId": activationId,
 	}
@@ -88,12 +89,12 @@ func ValidateLicense(activationId string) (*ActivationResponse, *model.ApiError)
 	response, err := http.Post(C.Prefix+"/licenses/validate", APPLICATION_JSON, bytes.NewBuffer(reqString))
 
 	if err != nil {
-		return nil, model.BadRequest(errors.Wrap(err, "unable to connect with license.signoz.io, please check your network connection"))
+		return nil, basemodel.BadRequest(errors.Wrap(err, "unable to connect with license.signoz.io, please check your network connection"))
 	}
 
 	body, err := io.ReadAll(response.Body)
 	if err != nil {
-		return nil, model.BadRequest(errors.Wrap(err, "failed to read validation response from license.signoz.io"))
+		return nil, basemodel.BadRequest(errors.Wrap(err, "failed to read validation response from license.signoz.io"))
 	}
 
 	defer response.Body.Close()
@@ -103,14 +104,14 @@ func ValidateLicense(activationId string) (*ActivationResponse, *model.ApiError)
 		a := ActivationResult{}
 		err = json.Unmarshal(body, &a)
 		if err != nil {
-			return nil, model.BadRequest(errors.Wrap(err, "failed to marshal license validation response"))
+			return nil, basemodel.BadRequest(errors.Wrap(err, "failed to marshal license validation response"))
 		}
 		return a.Data, nil
 	case 400, 401:
-		return nil, model.BadRequest(errors.Wrap(fmt.Errorf(string(body)),
+		return nil, basemodel.BadRequest(errors.Wrap(fmt.Errorf(string(body)),
 			"bad request error received from license.signoz.io"))
 	default:
-		return nil, model.InternalError(errors.Wrap(fmt.Errorf(string(body)),
+		return nil, basemodel.InternalError(errors.Wrap(fmt.Errorf(string(body)),
 			"internal error received from license.signoz.io"))
 	}
 
@@ -127,21 +128,21 @@ func NewPostRequestWithCtx(ctx context.Context, url string, contentType string,
 }
 
 // SendUsage reports the usage of signoz to license server
-func SendUsage(ctx context.Context, usage model.UsagePayload) *model.ApiError {
+func SendUsage(ctx context.Context, usage model.UsagePayload) *basemodel.ApiError {
 	reqString, _ := json.Marshal(usage)
 	req, err := NewPostRequestWithCtx(ctx, C.Prefix+"/usage", APPLICATION_JSON, bytes.NewBuffer(reqString))
 	if err != nil {
-		return model.BadRequest(errors.Wrap(err, "unable to create http request"))
+		return basemodel.BadRequest(errors.Wrap(err, "unable to create http request"))
 	}
 
 	res, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return model.BadRequest(errors.Wrap(err, "unable to connect with license.signoz.io, please check your network connection"))
+		return basemodel.BadRequest(errors.Wrap(err, "unable to connect with license.signoz.io, please check your network connection"))
 	}
 
 	body, err := io.ReadAll(res.Body)
 	if err != nil {
-		return model.BadRequest(errors.Wrap(err, "failed to read usage response from license.signoz.io"))
+		return basemodel.BadRequest(errors.Wrap(err, "failed to read usage response from license.signoz.io"))
 	}
 
 	defer res.Body.Close()
@@ -150,10 +151,10 @@ func SendUsage(ctx context.Context, usage model.UsagePayload) *model.ApiError {
 	case 200, 201:
 		return nil
 	case 400, 401:
-		return model.BadRequest(errors.Wrap(fmt.Errorf(string(body)),
+		return basemodel.BadRequest(errors.Wrap(fmt.Errorf(string(body)),
 			"bad request error received from license.signoz.io"))
 	default:
-		return model.InternalError(errors.Wrap(fmt.Errorf(string(body)),
+		return basemodel.InternalError(errors.Wrap(fmt.Errorf(string(body)),
 			"internal error received from license.signoz.io"))
 	}
 }

ee/query-service/license/manager.go

@@ -137,11 +137,11 @@ func (lm *Manager) LoadActiveLicense(features ...basemodel.Feature) error {
 	return nil
 }
 
-func (lm *Manager) GetLicenses(ctx context.Context) (response []model.License, apiError *model.ApiError) {
+func (lm *Manager) GetLicenses(ctx context.Context) (response []model.License, apiError *basemodel.ApiError) {
 
 	licenses, err := lm.repo.GetLicenses(ctx)
 	if err != nil {
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	for _, l := range licenses {
@@ -212,8 +212,8 @@ func (lm *Manager) Validate(ctx context.Context) (reterr error) {
 
 	response, apiError := validate.ValidateLicense(lm.activeLicense.ActivationId)
 	if apiError != nil {
-		zap.L().Error("failed to validate license", zap.Error(apiError.Err))
+		zap.L().Error("failed to validate license", zap.Any("apiError", apiError))
-		return apiError.Err
+		return apiError
 	}
 
 	if response.PlanDetails == lm.activeLicense.PlanDetails {
@@ -255,7 +255,7 @@ func (lm *Manager) Validate(ctx context.Context) (reterr error) {
 }
 
 // Activate activates a license key with signoz server
-func (lm *Manager) Activate(ctx context.Context, key string) (licenseResponse *model.License, errResponse *model.ApiError) {
+func (lm *Manager) Activate(ctx context.Context, key string) (licenseResponse *model.License, errResponse *basemodel.ApiError) {
 	defer func() {
 		if errResponse != nil {
 			userEmail, err := auth.GetEmailFromJwt(ctx)
@@ -268,7 +268,7 @@ func (lm *Manager) Activate(ctx context.Context, key string) (licenseResponse *m
 
 	response, apiError := validate.ActivateLicense(key, "")
 	if apiError != nil {
-		zap.L().Error("failed to activate license", zap.Error(apiError.Err))
+		zap.L().Error("failed to activate license", zap.Any("apiError", apiError))
 		return nil, apiError
 	}
 
@@ -283,14 +283,14 @@ func (lm *Manager) Activate(ctx context.Context, key string) (licenseResponse *m
 
 	if err != nil {
 		zap.L().Error("failed to activate license", zap.Error(err))
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	// store the license before activating it
 	err = lm.repo.InsertLicense(ctx, l)
 	if err != nil {
 		zap.L().Error("failed to activate license", zap.Error(err))
-		return nil, model.InternalError(err)
+		return nil, basemodel.InternalError(err)
 	}
 
 	// license is valid, activate it

ee/query-service/model/errors.go

@@ -1,107 +1,5 @@
 package model
 
-import (
-	"fmt"
-
-	basemodel "go.signoz.io/signoz/pkg/query-service/model"
-)
-
-type ApiError struct {
-	Typ basemodel.ErrorType
-	Err error
-}
-
-func (a *ApiError) Type() basemodel.ErrorType {
-	return a.Typ
-}
-
-func (a *ApiError) ToError() error {
-	if a != nil {
-		return a.Err
-	}
-	return a.Err
-}
-
-func (a *ApiError) Error() string {
-	return a.Err.Error()
-}
-
-func (a *ApiError) IsNil() bool {
-	return a == nil || a.Err == nil
-}
-
-// NewApiError returns a ApiError object of given type
-func NewApiError(typ basemodel.ErrorType, err error) *ApiError {
-	return &ApiError{
-		Typ: typ,
-		Err: err,
-	}
-}
-
-// BadRequest returns a ApiError object of bad request
-func BadRequest(err error) *ApiError {
-	return &ApiError{
-		Typ: basemodel.ErrorBadData,
-		Err: err,
-	}
-}
-
-// BadRequestStr returns a ApiError object of bad request for string input
-func BadRequestStr(s string) *ApiError {
-	return &ApiError{
-		Typ: basemodel.ErrorBadData,
-		Err: fmt.Errorf(s),
-	}
-}
-
-// InternalError returns a ApiError object of internal type
-func InternalError(err error) *ApiError {
-	return &ApiError{
-		Typ: basemodel.ErrorInternal,
-		Err: err,
-	}
-}
-
-// InternalErrorStr returns a ApiError object of internal type for string input
-func InternalErrorStr(s string) *ApiError {
-	return &ApiError{
-		Typ: basemodel.ErrorInternal,
-		Err: fmt.Errorf(s),
-	}
-}
-
-var (
-	ErrorNone                  basemodel.ErrorType = ""
-	ErrorTimeout               basemodel.ErrorType = "timeout"
-	ErrorCanceled              basemodel.ErrorType = "canceled"
-	ErrorExec                  basemodel.ErrorType = "execution"
-	ErrorBadData               basemodel.ErrorType = "bad_data"
-	ErrorInternal              basemodel.ErrorType = "internal"
-	ErrorUnavailable           basemodel.ErrorType = "unavailable"
-	ErrorNotFound              basemodel.ErrorType = "not_found"
-	ErrorNotImplemented        basemodel.ErrorType = "not_implemented"
-	ErrorUnauthorized          basemodel.ErrorType = "unauthorized"
-	ErrorForbidden             basemodel.ErrorType = "forbidden"
-	ErrorConflict              basemodel.ErrorType = "conflict"
-	ErrorStreamingNotSupported basemodel.ErrorType = "streaming is not supported"
-)
-
-func init() {
-	ErrorNone = basemodel.ErrorNone
-	ErrorTimeout = basemodel.ErrorTimeout
-	ErrorCanceled = basemodel.ErrorCanceled
-	ErrorExec = basemodel.ErrorExec
-	ErrorBadData = basemodel.ErrorBadData
-	ErrorInternal = basemodel.ErrorInternal
-	ErrorUnavailable = basemodel.ErrorUnavailable
-	ErrorNotFound = basemodel.ErrorNotFound
-	ErrorNotImplemented = basemodel.ErrorNotImplemented
-	ErrorUnauthorized = basemodel.ErrorUnauthorized
-	ErrorForbidden = basemodel.ErrorForbidden
-	ErrorConflict = basemodel.ErrorConflict
-	ErrorStreamingNotSupported = basemodel.ErrorStreamingNotSupported
-}
-
 type ErrUnsupportedAuth struct{}
 
 func (errUnsupportedAuth ErrUnsupportedAuth) Error() string {

ee/query-service/usage/manager.go

@@ -190,7 +190,7 @@ func (lm *Manager) UploadUsageWithExponentalBackOff(ctx context.Context, payload
 		} else if apiErr != nil {
 			// sleeping for exponential backoff
 			sleepDuration := RetryInterval * time.Duration(i)
-			zap.L().Error("failed to upload snapshot retrying after %v secs : %v", zap.Duration("sleepDuration", sleepDuration), zap.Error(apiErr.Err))
+			zap.L().Error("failed to upload snapshot retrying after %v secs : %v", zap.Duration("sleepDuration", sleepDuration), zap.Any("apiErr", apiErr))
 			time.Sleep(sleepDuration)
 		} else {
 			break

pkg/query-service/app/apdex.go

@@ -16,7 +16,7 @@ func (aH *APIHandler) setApdexSettings(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if err := dao.DB().SetApdexSettings(context.Background(), req); err != nil {
-		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal}, nil)
+		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal})
 		return
 	}
 
@@ -27,7 +27,7 @@ func (aH *APIHandler) getApdexSettings(w http.ResponseWriter, r *http.Request) {
 	services := r.URL.Query().Get("services")
 	apdexSet, err := dao.DB().GetApdexSettings(context.Background(), strings.Split(strings.TrimSpace(services), ","))
 	if err != nil {
-		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal}, nil)
+		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal})
 		return
 	}
 

pkg/query-service/app/auth.go

@@ -34,7 +34,7 @@ func (am *AuthMiddleware) ViewAccess(f func(http.ResponseWriter, *http.Request))
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorUnauthorized,
 				Err: err,
-			}, nil)
+			})
 			return
 		}
 
@@ -42,7 +42,7 @@ func (am *AuthMiddleware) ViewAccess(f func(http.ResponseWriter, *http.Request))
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorForbidden,
 				Err: errors.New("API is accessible to viewers/editors/admins"),
-			}, nil)
+			})
 			return
 		}
 		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
@@ -58,14 +58,14 @@ func (am *AuthMiddleware) EditAccess(f func(http.ResponseWriter, *http.Request))
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorUnauthorized,
 				Err: err,
-			}, nil)
+			})
 			return
 		}
 		if !(auth.IsEditor(user) || auth.IsAdmin(user)) {
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorForbidden,
 				Err: errors.New("API is accessible to editors/admins"),
-			}, nil)
+			})
 			return
 		}
 		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
@@ -81,7 +81,7 @@ func (am *AuthMiddleware) SelfAccess(f func(http.ResponseWriter, *http.Request))
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorUnauthorized,
 				Err: err,
-			}, nil)
+			})
 			return
 		}
 		id := mux.Vars(r)["id"]
@@ -89,7 +89,7 @@ func (am *AuthMiddleware) SelfAccess(f func(http.ResponseWriter, *http.Request))
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorForbidden,
 				Err: errors.New("API is accessible for self access or to the admins"),
-			}, nil)
+			})
 			return
 		}
 		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)
@@ -105,14 +105,14 @@ func (am *AuthMiddleware) AdminAccess(f func(http.ResponseWriter, *http.Request)
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorUnauthorized,
 				Err: err,
-			}, nil)
+			})
 			return
 		}
 		if !auth.IsAdmin(user) {
 			RespondError(w, &model.ApiError{
 				Typ: model.ErrorForbidden,
 				Err: errors.New("API is accessible to admins only"),
-			}, nil)
+			})
 			return
 		}
 		ctx := context.WithValue(r.Context(), constants.ContextUserKey, user)

pkg/query-service/app/clickhouseReader/reader.go

@@ -50,11 +50,11 @@ import (
 	"go.signoz.io/signoz/pkg/query-service/common"
 	"go.signoz.io/signoz/pkg/query-service/constants"
 	"go.signoz.io/signoz/pkg/query-service/dao"
-	chErrors "go.signoz.io/signoz/pkg/query-service/errors"
 	am "go.signoz.io/signoz/pkg/query-service/integrations/alertManager"
 	"go.signoz.io/signoz/pkg/query-service/interfaces"
 	"go.signoz.io/signoz/pkg/query-service/model"
 	v3 "go.signoz.io/signoz/pkg/query-service/model/v3"
+	chErrors "go.signoz.io/signoz/pkg/query-service/responseerrors"
 	"go.signoz.io/signoz/pkg/query-service/rules"
 	"go.signoz.io/signoz/pkg/query-service/telemetry"
 	"go.signoz.io/signoz/pkg/query-service/utils"

pkg/query-service/app/dashboards/model.go

@@ -16,7 +16,6 @@ import (
 	"github.com/jmoiron/sqlx"
 	"github.com/mitchellh/mapstructure"
 	"go.signoz.io/signoz/pkg/query-service/common"
-	"go.signoz.io/signoz/pkg/query-service/interfaces"
 	"go.signoz.io/signoz/pkg/query-service/model"
 	"go.uber.org/zap"
 )
@@ -43,7 +42,7 @@ func InitDB(dataSourceName string) (*sqlx.DB, error) {
 		return nil, err
 	}
 
-	table_schema := `CREATE TABLE IF NOT EXISTS dashboards (
+	tableSchema := `CREATE TABLE IF NOT EXISTS dashboards (
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		uuid TEXT NOT NULL UNIQUE,
 		created_at datetime NOT NULL,
@@ -51,24 +50,24 @@ func InitDB(dataSourceName string) (*sqlx.DB, error) {
 		data TEXT NOT NULL
 	);`
 
-	_, err = db.Exec(table_schema)
+	_, err = db.Exec(tableSchema)
 	if err != nil {
 		return nil, fmt.Errorf("error in creating dashboard table: %s", err.Error())
 	}
 
-	table_schema = `CREATE TABLE IF NOT EXISTS rules (
+	tableSchema = `CREATE TABLE IF NOT EXISTS rules (
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		updated_at datetime NOT NULL,
 		deleted INTEGER DEFAULT 0,
 		data TEXT NOT NULL
 	);`
 
-	_, err = db.Exec(table_schema)
+	_, err = db.Exec(tableSchema)
 	if err != nil {
 		return nil, fmt.Errorf("error in creating rules table: %s", err.Error())
 	}
 
-	table_schema = `CREATE TABLE IF NOT EXISTS notification_channels (
+	tableSchema = `CREATE TABLE IF NOT EXISTS notification_channels (
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		created_at datetime NOT NULL,
 		updated_at datetime NOT NULL,
@@ -78,12 +77,12 @@ func InitDB(dataSourceName string) (*sqlx.DB, error) {
 		data TEXT NOT NULL
 	);`
 
-	_, err = db.Exec(table_schema)
+	_, err = db.Exec(tableSchema)
 	if err != nil {
 		return nil, fmt.Errorf("error in creating notification_channles table: %s", err.Error())
 	}
 
-	tableSchema := `CREATE TABLE IF NOT EXISTS planned_maintenance (
+	tableSchema = `CREATE TABLE IF NOT EXISTS planned_maintenance (
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		name TEXT NOT NULL,
 		description TEXT,
@@ -99,7 +98,7 @@ func InitDB(dataSourceName string) (*sqlx.DB, error) {
 		return nil, fmt.Errorf("error in creating planned_maintenance table: %s", err.Error())
 	}
 
-	table_schema = `CREATE TABLE IF NOT EXISTS ttl_status (
+	tableSchema = `CREATE TABLE IF NOT EXISTS ttl_status (
 		id INTEGER PRIMARY KEY AUTOINCREMENT,
 		transaction_id TEXT NOT NULL,
 		created_at datetime NOT NULL,
@@ -110,7 +109,7 @@ func InitDB(dataSourceName string) (*sqlx.DB, error) {
 		status TEXT NOT NULL
 	);`
 
-	_, err = db.Exec(table_schema)
+	_, err = db.Exec(tableSchema)
 	if err != nil {
 		return nil, fmt.Errorf("error in creating ttl_status table: %s", err.Error())
 	}
@@ -192,7 +191,7 @@ func (c *Data) Scan(src interface{}) error {
 }
 
 // CreateDashboard creates a new dashboard
-func CreateDashboard(ctx context.Context, data map[string]interface{}, fm interfaces.FeatureLookup) (*Dashboard, *model.ApiError) {
+func CreateDashboard(ctx context.Context, data map[string]interface{}) (*Dashboard, *model.ApiError) {
 	dash := &Dashboard{
 		Data: data,
 	}
@@ -213,15 +212,7 @@ func CreateDashboard(ctx context.Context, data map[string]interface{}, fm interf
 	mapData, err := json.Marshal(dash.Data)
 	if err != nil {
 		zap.L().Error("Error in marshalling data field in dashboard: ", zap.Any("dashboard", dash), zap.Error(err))
-		return nil, &model.ApiError{Typ: model.ErrorExec, Err: err}
+		return nil, &model.ApiError{Typ: model.ErrorInternal, Err: err}
-	}
-
-	newCount, _ := countTraceAndLogsPanel(data)
-	if newCount > 0 {
-		fErr := checkFeatureUsage(fm, newCount)
-		if fErr != nil {
-			return nil, fErr
-		}
 	}
 
 	result, err := db.Exec("INSERT INTO dashboards (uuid, created_at, created_by, updated_at, updated_by, data) VALUES ($1, $2, $3, $4, $5, $6)",
@@ -229,19 +220,14 @@ func CreateDashboard(ctx context.Context, data map[string]interface{}, fm interf
 
 	if err != nil {
 		zap.L().Error("Error in inserting dashboard data: ", zap.Any("dashboard", dash), zap.Error(err))
-		return nil, &model.ApiError{Typ: model.ErrorExec, Err: err}
+		return nil, &model.ApiError{Typ: model.ErrorInternal, Err: err}
 	}
 	lastInsertId, err := result.LastInsertId()
 	if err != nil {
-		return nil, &model.ApiError{Typ: model.ErrorExec, Err: err}
+		return nil, &model.ApiError{Typ: model.ErrorInternal, Err: err}
 	}
 	dash.Id = int(lastInsertId)
 
-	traceAndLogsPanelUsage, _ := countTraceAndLogsPanel(data)
-	if traceAndLogsPanelUsage > 0 {
-		updateFeatureUsage(fm, traceAndLogsPanelUsage)
-	}
-
 	return dash, nil
 }
 
@@ -252,13 +238,13 @@ func GetDashboards(ctx context.Context) ([]Dashboard, *model.ApiError) {
 
 	err := db.Select(&dashboards, query)
 	if err != nil {
-		return nil, &model.ApiError{Typ: model.ErrorExec, Err: err}
+		return nil, &model.ApiError{Typ: model.ErrorInternal, Err: err}
 	}
 
 	return dashboards, nil
 }
 
-func DeleteDashboard(ctx context.Context, uuid string, fm interfaces.FeatureLookup) *model.ApiError {
+func DeleteDashboard(ctx context.Context, uuid string) *model.ApiError {
 
 	dashboard, dErr := GetDashboard(ctx, uuid)
 	if dErr != nil {
@@ -274,22 +260,9 @@ func DeleteDashboard(ctx context.Context, uuid string, fm interfaces.FeatureLook
 
 	query := `DELETE FROM dashboards WHERE uuid=?`
 
-	result, err := db.Exec(query, uuid)
+	_, err := db.Exec(query, uuid)
 	if err != nil {
-		return &model.ApiError{Typ: model.ErrorExec, Err: err}
+		return &model.ApiError{Typ: model.ErrorInternal, Err: err}
-	}
-
-	affectedRows, err := result.RowsAffected()
-	if err != nil {
-		return &model.ApiError{Typ: model.ErrorExec, Err: err}
-	}
-	if affectedRows == 0 {
-		return &model.ApiError{Typ: model.ErrorNotFound, Err: fmt.Errorf("no dashboard found with uuid: %s", uuid)}
-	}
-
-	traceAndLogsPanelUsage, _ := countTraceAndLogsPanel(dashboard.Data)
-	if traceAndLogsPanelUsage > 0 {
-		updateFeatureUsage(fm, -traceAndLogsPanelUsage)
 	}
 
 	return nil
@@ -308,7 +281,7 @@ func GetDashboard(ctx context.Context, uuid string) (*Dashboard, *model.ApiError
 	return &dashboard, nil
 }
 
-func UpdateDashboard(ctx context.Context, uuid string, data map[string]interface{}, fm interfaces.FeatureLookup) (*Dashboard, *model.ApiError) {
+func UpdateDashboard(ctx context.Context, uuid string, data map[string]interface{}) (*Dashboard, *model.ApiError) {
 
 	mapData, err := json.Marshal(data)
 	if err != nil {
@@ -330,14 +303,8 @@ func UpdateDashboard(ctx context.Context, uuid string, data map[string]interface
 	}
 
 	// check if the count of trace and logs QB panel has changed, if yes, then check feature flag count
-	existingCount, existingTotal := countTraceAndLogsPanel(dashboard.Data)
+	_, existingTotal := countTraceAndLogsPanel(dashboard.Data)
-	newCount, newTotal := countTraceAndLogsPanel(data)
+	_, newTotal := countTraceAndLogsPanel(data)
-	if newCount > existingCount {
-		err := checkFeatureUsage(fm, newCount-existingCount)
-		if err != nil {
-			return nil, err
-		}
-	}
 
 	if existingTotal > newTotal && existingTotal-newTotal > 1 {
 		// if the total count of panels has reduced by more than 1,
@@ -350,7 +317,6 @@ func UpdateDashboard(ctx context.Context, uuid string, data map[string]interface
 		if len(differenceIds) > 1 {
 			return nil, model.BadRequest(fmt.Errorf("deleting more than one panel is not supported"))
 		}
-
 	}
 
 	dashboard.UpdatedAt = time.Now()
@@ -362,11 +328,7 @@ func UpdateDashboard(ctx context.Context, uuid string, data map[string]interface
 
 	if err != nil {
 		zap.L().Error("Error in inserting dashboard data", zap.Any("data", data), zap.Error(err))
-		return nil, &model.ApiError{Typ: model.ErrorExec, Err: err}
+		return nil, &model.ApiError{Typ: model.ErrorInternal, Err: err}
-	}
-	if existingCount != newCount {
-		// if the count of trace and logs panel has changed, we need to update feature flag count as well
-		updateFeatureUsage(fm, newCount-existingCount)
 	}
 	return dashboard, nil
 }
@@ -389,51 +351,6 @@ func LockUnlockDashboard(ctx context.Context, uuid string, lock bool) *model.Api
 	return nil
 }
 
-func updateFeatureUsage(fm interfaces.FeatureLookup, usage int64) *model.ApiError {
-	feature, err := fm.GetFeatureFlag(model.QueryBuilderPanels)
-	if err != nil {
-		switch err.(type) {
-		case model.ErrFeatureUnavailable:
-			zap.L().Error("feature unavailable", zap.String("featureKey", model.QueryBuilderPanels), zap.Error(err))
-			return model.BadRequest(err)
-		default:
-			zap.L().Error("feature check failed", zap.String("featureKey", model.QueryBuilderPanels), zap.Error(err))
-			return model.BadRequest(err)
-		}
-	}
-	feature.Usage += usage
-	if feature.Usage >= feature.UsageLimit && feature.UsageLimit != -1 {
-		feature.Active = false
-	}
-	if feature.Usage < feature.UsageLimit || feature.UsageLimit == -1 {
-		feature.Active = true
-	}
-	err = fm.UpdateFeatureFlag(feature)
-	if err != nil {
-		return model.BadRequest(err)
-	}
-
-	return nil
-}
-
-func checkFeatureUsage(fm interfaces.FeatureLookup, usage int64) *model.ApiError {
-	feature, err := fm.GetFeatureFlag(model.QueryBuilderPanels)
-	if err != nil {
-		switch err.(type) {
-		case model.ErrFeatureUnavailable:
-			zap.L().Error("feature unavailable", zap.String("featureKey", model.QueryBuilderPanels), zap.Error(err))
-			return model.BadRequest(err)
-		default:
-			zap.L().Error("feature check failed", zap.String("featureKey", model.QueryBuilderPanels), zap.Error(err))
-			return model.BadRequest(err)
-		}
-	}
-	if feature.UsageLimit-(feature.Usage+usage) < 0 && feature.UsageLimit != -1 {
-		return model.BadRequest(fmt.Errorf("feature usage exceeded"))
-	}
-	return nil
-}
-
 // UpdateSlug updates the slug
 func (d *Dashboard) UpdateSlug() {
 	var title string

pkg/query-service/app/dashboards/provision.go

@@ -46,7 +46,7 @@ func readCurrentDir(dir string, fm interfaces.FeatureLookup) error {
 
 		id := data["uuid"]
 		if id == nil {
-			_, apiErr := CreateDashboard(context.Background(), data, fm)
+			_, apiErr := CreateDashboard(context.Background(), data)
 			if apiErr != nil {
 				zap.L().Error("Creating Dashboards: Error in file", zap.String("filename", filename), zap.Error(apiErr.Err))
 			}
@@ -65,12 +65,12 @@ func upsertDashboard(uuid string, data map[string]interface{}, filename string,
 	_, apiErr := GetDashboard(context.Background(), uuid)
 	if apiErr == nil {
 		zap.S().Infof("Creating Dashboards: Already exists: %s\t%s", filename, "Dashboard already present in database, Updating dashboard")
-		_, apiErr := UpdateDashboard(context.Background(), uuid, data, fm)
+		_, apiErr := UpdateDashboard(context.Background(), uuid, data)
 		return apiErr
 	}
 
 	zap.S().Infof("Creating Dashboards: UUID not found: %s\t%s", filename, "Dashboard not present in database, Creating dashboard")
-	_, apiErr = CreateDashboard(context.Background(), data, fm)
+	_, apiErr = CreateDashboard(context.Background(), data)
 	return apiErr
 }
 

pkg/query-service/app/ingestion_key.go

@@ -15,7 +15,7 @@ func (aH *APIHandler) insertIngestionKey(w http.ResponseWriter, r *http.Request)
 	}
 
 	if err := dao.DB().InsertIngestionKey(context.Background(), req); err != nil {
-		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal}, nil)
+		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal})
 		return
 	}
 
@@ -25,7 +25,7 @@ func (aH *APIHandler) insertIngestionKey(w http.ResponseWriter, r *http.Request)
 func (aH *APIHandler) getIngestionKeys(w http.ResponseWriter, r *http.Request) {
 	ingestionKeys, err := dao.DB().GetIngestionKeys(context.Background())
 	if err != nil {
-		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal}, nil)
+		RespondError(w, &model.ApiError{Err: err, Typ: model.ErrorInternal})
 		return
 	}
 

pkg/query-service/app/querier/querier.go

@@ -14,7 +14,7 @@ import (
 	metricsV3 "go.signoz.io/signoz/pkg/query-service/app/metrics/v3"
 	"go.signoz.io/signoz/pkg/query-service/app/queryBuilder"
 	tracesV3 "go.signoz.io/signoz/pkg/query-service/app/traces/v3"
-	chErrors "go.signoz.io/signoz/pkg/query-service/errors"
+	chErrors "go.signoz.io/signoz/pkg/query-service/responseerrors"
 
 	"go.signoz.io/signoz/pkg/query-service/cache"
 	"go.signoz.io/signoz/pkg/query-service/interfaces"

pkg/query-service/app/querier/v2/querier.go

@@ -14,7 +14,7 @@ import (
 	metricsV4 "go.signoz.io/signoz/pkg/query-service/app/metrics/v4"
 	"go.signoz.io/signoz/pkg/query-service/app/queryBuilder"
 	tracesV3 "go.signoz.io/signoz/pkg/query-service/app/traces/v3"
-	chErrors "go.signoz.io/signoz/pkg/query-service/errors"
+	chErrors "go.signoz.io/signoz/pkg/query-service/responseerrors"
 
 	"go.signoz.io/signoz/pkg/query-service/cache"
 	"go.signoz.io/signoz/pkg/query-service/interfaces"

pkg/query-service/dao/interface.go

@@ -37,7 +37,7 @@ type Queries interface {
 
 	GetIngestionKeys(ctx context.Context) ([]model.IngestionKey, *model.ApiError)
 
-	PrecheckLogin(ctx context.Context, email, sourceUrl string) (*model.PrecheckResponse, model.BaseApiError)
+	PrecheckLogin(ctx context.Context, email, sourceUrl string) (*model.PrecheckResponse, *model.ApiError)
 }
 
 type Mutations interface {

pkg/query-service/dao/sqlite/rbac.go

@@ -596,7 +596,7 @@ func (mds *ModelDaoSqlite) UpdateUserFlags(ctx context.Context, userId string, f
 	return flags, nil
 }
 
-func (mds *ModelDaoSqlite) PrecheckLogin(ctx context.Context, email, sourceUrl string) (*model.PrecheckResponse, model.BaseApiError) {
+func (mds *ModelDaoSqlite) PrecheckLogin(ctx context.Context, email, sourceUrl string) (*model.PrecheckResponse, *model.ApiError) {
 	// assume user is valid unless proven otherwise and assign default values for rest of the fields
 	resp := &model.PrecheckResponse{IsUser: true, CanSelfRegister: false, SSO: false, SsoUrl: "", SsoError: ""}
 

pkg/query-service/model/response.go

@@ -14,6 +14,25 @@ import (
 	"k8s.io/apimachinery/pkg/labels"
 )
 
+type status string
+
+const (
+	StatusSuccess status = "success"
+	StatusError   status = "error"
+)
+
+type APIResponse struct {
+	Status status          `json:"status"`
+	Data   interface{}     `json:"data,omitempty"`
+	Error  StructuredError `json:"error,omitempty"`
+}
+
+type StructuredError struct {
+	Msg    string            `json:"msg"`
+	DocURL string            `json:"docURL,omitempty"`
+	Errors []StructuredError `json:"errors,omitempty"`
+}
+
 type BaseApiError interface {
 	Type() ErrorType
 	ToError() error
@@ -22,8 +41,10 @@ type BaseApiError interface {
 }
 
 type ApiError struct {
-	Typ ErrorType
+	Typ    ErrorType
-	Err error
+	Err    error
+	DocURL string
+	Errors []StructuredError
 }
 
 func (a *ApiError) Type() ErrorType {
@@ -63,8 +84,8 @@ const (
 	ErrorUnauthorized             ErrorType = "unauthorized"
 	ErrorForbidden                ErrorType = "forbidden"
 	ErrorConflict                 ErrorType = "conflict"
-	ErrorStreamingNotSupported    ErrorType = "streaming is not supported"
+	ErrorStreamingNotSupported    ErrorType = "streaming_is_not_supported"
-	ErrorStatusServiceUnavailable ErrorType = "service unavailable"
+	ErrorStatusServiceUnavailable ErrorType = "service_unavailable"
 )
 
 // BadRequest returns a ApiError object of bad request
@@ -75,14 +96,6 @@ func BadRequest(err error) *ApiError {
 	}
 }
 
-// BadRequestStr returns a ApiError object of bad request
-func BadRequestStr(s string) *ApiError {
-	return &ApiError{
-		Typ: ErrorBadData,
-		Err: fmt.Errorf(s),
-	}
-}
-
 // InternalError returns a ApiError object of internal type
 func InternalError(err error) *ApiError {
 	return &ApiError{

pkg/query-service/responseerrors/clickhouse.go

@@ -1,6 +1,8 @@
-package errors
+package responseerrors
 
-import "errors"
+import (
+	"errors"
+)
 
 var (
 	// ErrResourceBytesLimitExceeded is returned when the resource bytes limit is exceeded

pkg/query-service/tests/integration/logparsingpipeline_test.go

@@ -537,7 +537,7 @@ func (tb *LogPipelinesTestBed) PostPipelinesToQSExpectingStatusCode(
 		)
 	}
 
-	var result app.ApiResponse
+	var result model.APIResponse
 	err = json.Unmarshal(responseBody, &result)
 	if err != nil {
 		tb.t.Fatalf(
@@ -587,7 +587,7 @@ func (tb *LogPipelinesTestBed) GetPipelinesFromQS() *logparsingpipeline.Pipeline
 		)
 	}
 
-	var result app.ApiResponse
+	var result model.APIResponse
 	err = json.Unmarshal(responseBody, &result)
 	if err != nil {
 		tb.t.Fatalf(
@@ -718,7 +718,7 @@ func (tb *LogPipelinesTestBed) assertNewAgentGetsPipelinesOnConnection(
 	)
 }
 
-func unmarshalPipelinesResponse(apiResponse *app.ApiResponse) (
+func unmarshalPipelinesResponse(apiResponse *model.APIResponse) (
 	*logparsingpipeline.PipelinesResponse,
 	error,
 ) {

pkg/query-service/tests/integration/signoz_integrations_test.go

@@ -500,7 +500,7 @@ func (tb *IntegrationsTestBed) GetDashboardByIdFromQS(dashboardUuid string) *das
 func (tb *IntegrationsTestBed) RequestQS(
 	path string,
 	postData interface{},
-) *app.ApiResponse {
+) *model.APIResponse {
 	req, err := NewAuthenticatedTestRequest(
 		tb.testUser, path, postData,
 	)
@@ -523,7 +523,7 @@ func (tb *IntegrationsTestBed) RequestQS(
 		)
 	}
 
-	var result app.ApiResponse
+	var result model.APIResponse
 	err = json.Unmarshal(responseBody, &result)
 	if err != nil {
 		tb.t.Fatalf(