Generic-based internal HTTP API (#2626)

* Generic-based internal HTTP API (tested out on a few endpoints in the federation API)

* Add `PerformInvite`

* More tweaks

* Fix metric name

* Fix LookupStateIDs

* Lots of changes to clients

* Some serverside stuff

* Some error handling

* Use paths as metric names

* Revert "Use paths as metric names"

This reverts commit a9323a6a343f5ce6461a2e5bd570fe06465f1b15.

* Namespace metric names

* Remove duplicate entry

* Remove another duplicate entry

* Tweak error handling

* Some more tweaks

* Update error behaviour

* Some more error tweaking

* Fix API path for `PerformDeleteKeys`

* Fix another path

* Tweak federation client proxying

* Fix another path

* Don't return typed nils

* Some more tweaks, not that it makes any difference

* Tweak federation client proxying

* Maybe fix the key backup test

8 files changed, 425 insertions, 671 deletions

diff --git a/userapi/api/api.go b/userapi/api/api.go
index df9408ac..388f97cb 100644
--- a/userapi/api/api.go
+++ b/userapi/api/api.go
@@ -100,7 +100,7 @@ type ClientUserAPI interface {
 	QueryNotifications(ctx context.Context, req *QueryNotificationsRequest, res *QueryNotificationsResponse) error
 	InputAccountData(ctx context.Context, req *InputAccountDataRequest, res *InputAccountDataResponse) error
 	PerformKeyBackup(ctx context.Context, req *PerformKeyBackupRequest, res *PerformKeyBackupResponse) error
-	QueryKeyBackup(ctx context.Context, req *QueryKeyBackupRequest, res *QueryKeyBackupResponse)
+	QueryKeyBackup(ctx context.Context, req *QueryKeyBackupRequest, res *QueryKeyBackupResponse) error
 
 	QueryThreePIDsForLocalpart(ctx context.Context, req *QueryThreePIDsForLocalpartRequest, res *QueryThreePIDsForLocalpartResponse) error
 	QueryLocalpartForThreePID(ctx context.Context, req *QueryLocalpartForThreePIDRequest, res *QueryLocalpartForThreePIDResponse) error
diff --git a/userapi/api/api_trace.go b/userapi/api/api_trace.go
index 6d8d2800..7e2f6961 100644
--- a/userapi/api/api_trace.go
+++ b/userapi/api/api_trace.go
@@ -94,9 +94,10 @@ func (t *UserInternalAPITrace) PerformPushRulesPut(ctx context.Context, req *Per
 	util.GetLogger(ctx).Infof("PerformPushRulesPut req=%+v res=%+v", js(req), js(res))
 	return err
 }
-func (t *UserInternalAPITrace) QueryKeyBackup(ctx context.Context, req *QueryKeyBackupRequest, res *QueryKeyBackupResponse) {
-	t.Impl.QueryKeyBackup(ctx, req, res)
+func (t *UserInternalAPITrace) QueryKeyBackup(ctx context.Context, req *QueryKeyBackupRequest, res *QueryKeyBackupResponse) error {
+	err := t.Impl.QueryKeyBackup(ctx, req, res)
 	util.GetLogger(ctx).Infof("QueryKeyBackup req=%+v res=%+v", js(req), js(res))
+	return err
 }
 func (t *UserInternalAPITrace) QueryProfile(ctx context.Context, req *QueryProfileRequest, res *QueryProfileResponse) error {
 	err := t.Impl.QueryProfile(ctx, req, res)
diff --git a/userapi/internal/api.go b/userapi/internal/api.go
index 422eb076..78b226d4 100644
--- a/userapi/internal/api.go
+++ b/userapi/internal/api.go
@@ -192,7 +192,9 @@ func (a *UserInternalAPI) PerformDeviceDeletion(ctx context.Context, req *api.Pe
 		deleteReq.KeyIDs = append(deleteReq.KeyIDs, gomatrixserverlib.KeyID(keyID))
 	}
 	deleteRes := &keyapi.PerformDeleteKeysResponse{}
-	a.KeyAPI.PerformDeleteKeys(ctx, deleteReq, deleteRes)
+	if err := a.KeyAPI.PerformDeleteKeys(ctx, deleteReq, deleteRes); err != nil {
+		return err
+	}
 	if err := deleteRes.Error; err != nil {
 		return fmt.Errorf("a.KeyAPI.PerformDeleteKeys: %w", err)
 	}
@@ -211,10 +213,12 @@ func (a *UserInternalAPI) deviceListUpdate(userID string, deviceIDs []string) er
 	}
 
 	var uploadRes keyapi.PerformUploadKeysResponse
-	a.KeyAPI.PerformUploadKeys(context.Background(), &keyapi.PerformUploadKeysRequest{
+	if err := a.KeyAPI.PerformUploadKeys(context.Background(), &keyapi.PerformUploadKeysRequest{
 		UserID:     userID,
 		DeviceKeys: deviceKeys,
-	}, &uploadRes)
+	}, &uploadRes); err != nil {
+		return err
+	}
 	if uploadRes.Error != nil {
 		return fmt.Errorf("failed to delete device keys: %v", uploadRes.Error)
 	}
@@ -268,7 +272,7 @@ func (a *UserInternalAPI) PerformDeviceUpdate(ctx context.Context, req *api.Perf
 	if req.DisplayName != nil && dev.DisplayName != *req.DisplayName {
 		// display name has changed: update the device key
 		var uploadRes keyapi.PerformUploadKeysResponse
-		a.KeyAPI.PerformUploadKeys(context.Background(), &keyapi.PerformUploadKeysRequest{
+		if err := a.KeyAPI.PerformUploadKeys(context.Background(), &keyapi.PerformUploadKeysRequest{
 			UserID: req.RequestingUserID,
 			DeviceKeys: []keyapi.DeviceKeys{
 				{
@@ -279,7 +283,9 @@ func (a *UserInternalAPI) PerformDeviceUpdate(ctx context.Context, req *api.Perf
 				},
 			},
 			OnlyDisplayNameUpdates: true,
-		}, &uploadRes)
+		}, &uploadRes); err != nil {
+			return err
+		}
 		if uploadRes.Error != nil {
 			return fmt.Errorf("failed to update device key display name: %v", uploadRes.Error)
 		}
@@ -479,7 +485,9 @@ func (a *UserInternalAPI) PerformAccountDeactivation(ctx context.Context, req *a
 		UserID: fmt.Sprintf("@%s:%s", req.Localpart, a.ServerName),
 	}
 	evacuateRes := &rsapi.PerformAdminEvacuateUserResponse{}
-	a.RSAPI.PerformAdminEvacuateUser(ctx, evacuateReq, evacuateRes)
+	if err := a.RSAPI.PerformAdminEvacuateUser(ctx, evacuateReq, evacuateRes); err != nil {
+		return err
+	}
 	if err := evacuateRes.Error; err != nil {
 		logrus.WithError(err).Errorf("Failed to evacuate user after account deactivation")
 	}
@@ -538,9 +546,6 @@ func (a *UserInternalAPI) PerformKeyBackup(ctx context.Context, req *api.Perform
 		if req.Version == "" {
 			res.BadInput = true
 			res.Error = "must specify a version to delete"
-			if res.Error != "" {
-				return fmt.Errorf(res.Error)
-			}
 			return nil
 		}
 		exists, err := a.DB.DeleteKeyBackup(ctx, req.UserID, req.Version)
@@ -549,9 +554,6 @@ func (a *UserInternalAPI) PerformKeyBackup(ctx context.Context, req *api.Perform
 		}
 		res.Exists = exists
 		res.Version = req.Version
-		if res.Error != "" {
-			return fmt.Errorf(res.Error)
-		}
 		return nil
 	}
 	// Create metadata
@@ -562,9 +564,6 @@ func (a *UserInternalAPI) PerformKeyBackup(ctx context.Context, req *api.Perform
 		}
 		res.Exists = err == nil
 		res.Version = version
-		if res.Error != "" {
-			return fmt.Errorf(res.Error)
-		}
 		return nil
 	}
 	// Update metadata
@@ -575,16 +574,10 @@ func (a *UserInternalAPI) PerformKeyBackup(ctx context.Context, req *api.Perform
 		}
 		res.Exists = err == nil
 		res.Version = req.Version
-		if res.Error != "" {
-			return fmt.Errorf(res.Error)
-		}
 		return nil
 	}
 	// Upload Keys for a specific version metadata
 	a.uploadBackupKeys(ctx, req, res)
-	if res.Error != "" {
-		return fmt.Errorf(res.Error)
-	}
 	return nil
 }
 
@@ -627,16 +620,16 @@ func (a *UserInternalAPI) uploadBackupKeys(ctx context.Context, req *api.Perform
 	res.KeyETag = etag
 }
 
-func (a *UserInternalAPI) QueryKeyBackup(ctx context.Context, req *api.QueryKeyBackupRequest, res *api.QueryKeyBackupResponse) {
+func (a *UserInternalAPI) QueryKeyBackup(ctx context.Context, req *api.QueryKeyBackupRequest, res *api.QueryKeyBackupResponse) error {
 	version, algorithm, authData, etag, deleted, err := a.DB.GetKeyBackup(ctx, req.UserID, req.Version)
 	res.Version = version
 	if err != nil {
 		if err == sql.ErrNoRows {
 			res.Exists = false
-			return
+			return nil
 		}
 		res.Error = fmt.Sprintf("failed to query key backup: %s", err)
-		return
+		return nil
 	}
 	res.Algorithm = algorithm
 	res.AuthData = authData
@@ -648,15 +641,16 @@ func (a *UserInternalAPI) QueryKeyBackup(ctx context.Context, req *api.QueryKeyB
 		if err != nil {
 			res.Error = fmt.Sprintf("failed to count keys: %s", err)
 		}
-		return
+		return nil
 	}
 
 	result, err := a.DB.GetBackupKeys(ctx, version, req.UserID, req.KeysForRoomID, req.KeysForSessionID)
 	if err != nil {
 		res.Error = fmt.Sprintf("failed to query keys: %s", err)
-		return
+		return nil
 	}
 	res.Keys = result
+	return nil
 }
 
 func (a *UserInternalAPI) QueryNotifications(ctx context.Context, req *api.QueryNotificationsRequest, res *api.QueryNotificationsResponse) error {
diff --git a/userapi/inthttp/client.go b/userapi/inthttp/client.go
index 23c335cf..a375d6ca 100644
--- a/userapi/inthttp/client.go
+++ b/userapi/inthttp/client.go
@@ -21,7 +21,6 @@ import (
 
 	"github.com/matrix-org/dendrite/internal/httputil"
 	"github.com/matrix-org/dendrite/userapi/api"
-	"github.com/opentracing/opentracing-go"
 )
 
 // HTTP paths for the internal HTTP APIs
@@ -84,11 +83,10 @@ type httpUserInternalAPI struct {
 }
 
 func (h *httpUserInternalAPI) InputAccountData(ctx context.Context, req *api.InputAccountDataRequest, res *api.InputAccountDataResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "InputAccountData")
-	defer span.Finish()
-
-	apiURL := h.apiURL + InputAccountDataPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+	return httputil.CallInternalRPCAPI(
+		"InputAccountData", h.apiURL+InputAccountDataPath,
+		h.httpClient, ctx, req, res,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformAccountCreation(
@@ -96,11 +94,10 @@ func (h *httpUserInternalAPI) PerformAccountCreation(
 	request *api.PerformAccountCreationRequest,
 	response *api.PerformAccountCreationResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformAccountCreation")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformAccountCreationPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformAccountCreation", h.apiURL+PerformAccountCreationPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformPasswordUpdate(
@@ -108,11 +105,10 @@ func (h *httpUserInternalAPI) PerformPasswordUpdate(
 	request *api.PerformPasswordUpdateRequest,
 	response *api.PerformPasswordUpdateResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformPasswordUpdate")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformPasswordUpdatePath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformPasswordUpdate", h.apiURL+PerformPasswordUpdatePath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformDeviceCreation(
@@ -120,11 +116,10 @@ func (h *httpUserInternalAPI) PerformDeviceCreation(
 	request *api.PerformDeviceCreationRequest,
 	response *api.PerformDeviceCreationResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformDeviceCreation")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformDeviceCreationPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformDeviceCreation", h.apiURL+PerformDeviceCreationPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformDeviceDeletion(
@@ -132,47 +127,54 @@ func (h *httpUserInternalAPI) PerformDeviceDeletion(
 	request *api.PerformDeviceDeletionRequest,
 	response *api.PerformDeviceDeletionResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformDeviceDeletion")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformDeviceDeletionPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformDeviceDeletion", h.apiURL+PerformDeviceDeletionPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformLastSeenUpdate(
 	ctx context.Context,
-	req *api.PerformLastSeenUpdateRequest,
-	res *api.PerformLastSeenUpdateResponse,
+	request *api.PerformLastSeenUpdateRequest,
+	response *api.PerformLastSeenUpdateResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformLastSeen")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformLastSeenUpdatePath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+	return httputil.CallInternalRPCAPI(
+		"PerformLastSeen", h.apiURL+PerformLastSeenUpdatePath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformDeviceUpdate(ctx context.Context, req *api.PerformDeviceUpdateRequest, res *api.PerformDeviceUpdateResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformDeviceUpdate")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformDeviceUpdatePath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) PerformDeviceUpdate(
+	ctx context.Context,
+	request *api.PerformDeviceUpdateRequest,
+	response *api.PerformDeviceUpdateResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformDeviceUpdate", h.apiURL+PerformDeviceUpdatePath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformAccountDeactivation(ctx context.Context, req *api.PerformAccountDeactivationRequest, res *api.PerformAccountDeactivationResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformAccountDeactivation")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformAccountDeactivationPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) PerformAccountDeactivation(
+	ctx context.Context,
+	request *api.PerformAccountDeactivationRequest,
+	response *api.PerformAccountDeactivationResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformAccountDeactivation", h.apiURL+PerformAccountDeactivationPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformOpenIDTokenCreation(ctx context.Context, request *api.PerformOpenIDTokenCreationRequest, response *api.PerformOpenIDTokenCreationResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformOpenIDTokenCreation")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformOpenIDTokenCreationPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+func (h *httpUserInternalAPI) PerformOpenIDTokenCreation(
+	ctx context.Context,
+	request *api.PerformOpenIDTokenCreationRequest,
+	response *api.PerformOpenIDTokenCreationResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformOpenIDTokenCreation", h.apiURL+PerformOpenIDTokenCreationPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) QueryProfile(
@@ -180,11 +182,10 @@ func (h *httpUserInternalAPI) QueryProfile(
 	request *api.QueryProfileRequest,
 	response *api.QueryProfileResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryProfile")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryProfilePath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"QueryProfile", h.apiURL+QueryProfilePath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) QueryDeviceInfos(
@@ -192,11 +193,10 @@ func (h *httpUserInternalAPI) QueryDeviceInfos(
 	request *api.QueryDeviceInfosRequest,
 	response *api.QueryDeviceInfosResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryDeviceInfos")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryDeviceInfosPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"QueryDeviceInfos", h.apiURL+QueryDeviceInfosPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) QueryAccessToken(
@@ -204,72 +204,87 @@ func (h *httpUserInternalAPI) QueryAccessToken(
 	request *api.QueryAccessTokenRequest,
 	response *api.QueryAccessTokenResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryAccessToken")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryAccessTokenPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"QueryAccessToken", h.apiURL+QueryAccessTokenPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryDevices(ctx context.Context, req *api.QueryDevicesRequest, res *api.QueryDevicesResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryDevices")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryDevicesPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryDevices(
+	ctx context.Context,
+	request *api.QueryDevicesRequest,
+	response *api.QueryDevicesResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryDevices", h.apiURL+QueryDevicesPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryAccountData(ctx context.Context, req *api.QueryAccountDataRequest, res *api.QueryAccountDataResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryAccountData")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryAccountDataPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryAccountData(
+	ctx context.Context,
+	request *api.QueryAccountDataRequest,
+	response *api.QueryAccountDataResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryAccountData", h.apiURL+QueryAccountDataPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QuerySearchProfiles(ctx context.Context, req *api.QuerySearchProfilesRequest, res *api.QuerySearchProfilesResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QuerySearchProfiles")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QuerySearchProfilesPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QuerySearchProfiles(
+	ctx context.Context,
+	request *api.QuerySearchProfilesRequest,
+	response *api.QuerySearchProfilesResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QuerySearchProfiles", h.apiURL+QuerySearchProfilesPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryOpenIDToken(ctx context.Context, req *api.QueryOpenIDTokenRequest, res *api.QueryOpenIDTokenResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryOpenIDToken")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryOpenIDTokenPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryOpenIDToken(
+	ctx context.Context,
+	request *api.QueryOpenIDTokenRequest,
+	response *api.QueryOpenIDTokenResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryOpenIDToken", h.apiURL+QueryOpenIDTokenPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformKeyBackup(ctx context.Context, req *api.PerformKeyBackupRequest, res *api.PerformKeyBackupResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformKeyBackup")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformKeyBackupPath
-	err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
-	if err != nil {
-		res.Error = err.Error()
-	}
-	return nil
+func (h *httpUserInternalAPI) PerformKeyBackup(
+	ctx context.Context,
+	request *api.PerformKeyBackupRequest,
+	response *api.PerformKeyBackupResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformKeyBackup", h.apiURL+PerformKeyBackupPath,
+		h.httpClient, ctx, request, response,
+	)
 }
-func (h *httpUserInternalAPI) QueryKeyBackup(ctx context.Context, req *api.QueryKeyBackupRequest, res *api.QueryKeyBackupResponse) {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryKeyBackup")
-	defer span.Finish()
 
-	apiURL := h.apiURL + QueryKeyBackupPath
-	err := httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
-	if err != nil {
-		res.Error = err.Error()
-	}
+func (h *httpUserInternalAPI) QueryKeyBackup(
+	ctx context.Context,
+	request *api.QueryKeyBackupRequest,
+	response *api.QueryKeyBackupResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryKeyBackup", h.apiURL+QueryKeyBackupPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryNotifications(ctx context.Context, req *api.QueryNotificationsRequest, res *api.QueryNotificationsResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryNotifications")
-	defer span.Finish()
-
-	return httputil.PostJSON(ctx, span, h.httpClient, h.apiURL+QueryNotificationsPath, req, res)
+func (h *httpUserInternalAPI) QueryNotifications(
+	ctx context.Context,
+	request *api.QueryNotificationsRequest,
+	response *api.QueryNotificationsResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryNotifications", h.apiURL+QueryNotificationsPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformPusherSet(
@@ -277,27 +292,32 @@ func (h *httpUserInternalAPI) PerformPusherSet(
 	request *api.PerformPusherSetRequest,
 	response *struct{},
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformPusherSet")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformPusherSetPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformPusherSet", h.apiURL+PerformPusherSetPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformPusherDeletion(ctx context.Context, req *api.PerformPusherDeletionRequest, res *struct{}) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformPusherDeletion")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformPusherDeletionPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) PerformPusherDeletion(
+	ctx context.Context,
+	request *api.PerformPusherDeletionRequest,
+	response *struct{},
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformPusherDeletion", h.apiURL+PerformPusherDeletionPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryPushers(ctx context.Context, req *api.QueryPushersRequest, res *api.QueryPushersResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryPushers")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryPushersPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryPushers(
+	ctx context.Context,
+	request *api.QueryPushersRequest,
+	response *api.QueryPushersResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryPushers", h.apiURL+QueryPushersPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformPushRulesPut(
@@ -305,89 +325,117 @@ func (h *httpUserInternalAPI) PerformPushRulesPut(
 	request *api.PerformPushRulesPutRequest,
 	response *struct{},
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformPushRulesPut")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformPushRulesPutPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformPushRulesPut", h.apiURL+PerformPushRulesPutPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryPushRules(ctx context.Context, req *api.QueryPushRulesRequest, res *api.QueryPushRulesResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryPushRules")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryPushRulesPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryPushRules(
+	ctx context.Context,
+	request *api.QueryPushRulesRequest,
+	response *api.QueryPushRulesResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryPushRules", h.apiURL+QueryPushRulesPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) SetAvatarURL(ctx context.Context, req *api.PerformSetAvatarURLRequest, res *api.PerformSetAvatarURLResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, PerformSetAvatarURLPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformSetAvatarURLPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) SetAvatarURL(
+	ctx context.Context,
+	request *api.PerformSetAvatarURLRequest,
+	response *api.PerformSetAvatarURLResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"SetAvatarURL", h.apiURL+PerformSetAvatarURLPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryNumericLocalpart(ctx context.Context, res *api.QueryNumericLocalpartResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, QueryNumericLocalpartPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryNumericLocalpartPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, struct{}{}, res)
+func (h *httpUserInternalAPI) QueryNumericLocalpart(
+	ctx context.Context,
+	response *api.QueryNumericLocalpartResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryNumericLocalpart", h.apiURL+QueryNumericLocalpartPath,
+		h.httpClient, ctx, &struct{}{}, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryAccountAvailability(ctx context.Context, req *api.QueryAccountAvailabilityRequest, res *api.QueryAccountAvailabilityResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, QueryAccountAvailabilityPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryAccountAvailabilityPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryAccountAvailability(
+	ctx context.Context,
+	request *api.QueryAccountAvailabilityRequest,
+	response *api.QueryAccountAvailabilityResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryAccountAvailability", h.apiURL+QueryAccountAvailabilityPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryAccountByPassword(ctx context.Context, req *api.QueryAccountByPasswordRequest, res *api.QueryAccountByPasswordResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, QueryAccountByPasswordPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryAccountByPasswordPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryAccountByPassword(
+	ctx context.Context,
+	request *api.QueryAccountByPasswordRequest,
+	response *api.QueryAccountByPasswordResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryAccountByPassword", h.apiURL+QueryAccountByPasswordPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) SetDisplayName(ctx context.Context, req *api.PerformUpdateDisplayNameRequest, res *struct{}) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, PerformSetDisplayNamePath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformSetDisplayNamePath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) SetDisplayName(
+	ctx context.Context,
+	request *api.PerformUpdateDisplayNameRequest,
+	response *struct{},
+) error {
+	return httputil.CallInternalRPCAPI(
+		"SetDisplayName", h.apiURL+PerformSetDisplayNamePath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryLocalpartForThreePID(ctx context.Context, req *api.QueryLocalpartForThreePIDRequest, res *api.QueryLocalpartForThreePIDResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, QueryLocalpartForThreePIDPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryLocalpartForThreePIDPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryLocalpartForThreePID(
+	ctx context.Context,
+	request *api.QueryLocalpartForThreePIDRequest,
+	response *api.QueryLocalpartForThreePIDResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryLocalpartForThreePID", h.apiURL+QueryLocalpartForThreePIDPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) QueryThreePIDsForLocalpart(ctx context.Context, req *api.QueryThreePIDsForLocalpartRequest, res *api.QueryThreePIDsForLocalpartResponse) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, QueryThreePIDsForLocalpartPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryThreePIDsForLocalpartPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) QueryThreePIDsForLocalpart(
+	ctx context.Context,
+	request *api.QueryThreePIDsForLocalpartRequest,
+	response *api.QueryThreePIDsForLocalpartResponse,
+) error {
+	return httputil.CallInternalRPCAPI(
+		"QueryThreePIDsForLocalpart", h.apiURL+QueryThreePIDsForLocalpartPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformForgetThreePID(ctx context.Context, req *api.PerformForgetThreePIDRequest, res *struct{}) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, PerformForgetThreePIDPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformForgetThreePIDPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) PerformForgetThreePID(
+	ctx context.Context,
+	request *api.PerformForgetThreePIDRequest,
+	response *struct{},
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformForgetThreePID", h.apiURL+PerformForgetThreePIDPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
-func (h *httpUserInternalAPI) PerformSaveThreePIDAssociation(ctx context.Context, req *api.PerformSaveThreePIDAssociationRequest, res *struct{}) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, PerformSaveThreePIDAssociationPath)
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformSaveThreePIDAssociationPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, req, res)
+func (h *httpUserInternalAPI) PerformSaveThreePIDAssociation(
+	ctx context.Context,
+	request *api.PerformSaveThreePIDAssociationRequest,
+	response *struct{},
+) error {
+	return httputil.CallInternalRPCAPI(
+		"PerformSaveThreePIDAssociation", h.apiURL+PerformSaveThreePIDAssociationPath,
+		h.httpClient, ctx, request, response,
+	)
 }
diff --git a/userapi/inthttp/client_logintoken.go b/userapi/inthttp/client_logintoken.go
index 366a9709..211b1b7a 100644
--- a/userapi/inthttp/client_logintoken.go
+++ b/userapi/inthttp/client_logintoken.go
@@ -19,7 +19,6 @@ import (
 
 	"github.com/matrix-org/dendrite/internal/httputil"
 	"github.com/matrix-org/dendrite/userapi/api"
-	"github.com/opentracing/opentracing-go"
 )
 
 const (
@@ -33,11 +32,10 @@ func (h *httpUserInternalAPI) PerformLoginTokenCreation(
 	request *api.PerformLoginTokenCreationRequest,
 	response *api.PerformLoginTokenCreationResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformLoginTokenCreation")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformLoginTokenCreationPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformLoginTokenCreation", h.apiURL+PerformLoginTokenCreationPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) PerformLoginTokenDeletion(
@@ -45,11 +43,10 @@ func (h *httpUserInternalAPI) PerformLoginTokenDeletion(
 	request *api.PerformLoginTokenDeletionRequest,
 	response *api.PerformLoginTokenDeletionResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "PerformLoginTokenDeletion")
-	defer span.Finish()
-
-	apiURL := h.apiURL + PerformLoginTokenDeletionPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"PerformLoginTokenDeletion", h.apiURL+PerformLoginTokenDeletionPath,
+		h.httpClient, ctx, request, response,
+	)
 }
 
 func (h *httpUserInternalAPI) QueryLoginToken(
@@ -57,9 +54,8 @@ func (h *httpUserInternalAPI) QueryLoginToken(
 	request *api.QueryLoginTokenRequest,
 	response *api.QueryLoginTokenResponse,
 ) error {
-	span, ctx := opentracing.StartSpanFromContext(ctx, "QueryLoginToken")
-	defer span.Finish()
-
-	apiURL := h.apiURL + QueryLoginTokenPath
-	return httputil.PostJSON(ctx, span, h.httpClient, apiURL, request, response)
+	return httputil.CallInternalRPCAPI(
+		"QueryLoginToken", h.apiURL+QueryLoginTokenPath,
+		h.httpClient, ctx, request, response,
+	)
 }
diff --git a/userapi/inthttp/server.go b/userapi/inthttp/server.go
index ad532b90..99148b76 100644
--- a/userapi/inthttp/server.go
+++ b/userapi/inthttp/server.go
@@ -15,8 +15,6 @@
 package inthttp
 
 import (
-	"encoding/json"
-	"fmt"
 	"net/http"
 
 	"github.com/gorilla/mux"
@@ -29,339 +27,134 @@ import (
 func AddRoutes(internalAPIMux *mux.Router, s api.UserInternalAPI) {
 	addRoutesLoginToken(internalAPIMux, s)
 
-	internalAPIMux.Handle(PerformAccountCreationPath,
-		httputil.MakeInternalAPI("performAccountCreation", func(req *http.Request) util.JSONResponse {
-			request := api.PerformAccountCreationRequest{}
-			response := api.PerformAccountCreationResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformAccountCreation(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+	internalAPIMux.Handle(
+		PerformAccountCreationPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformAccountCreation", s.PerformAccountCreation),
 	)
-	internalAPIMux.Handle(PerformPasswordUpdatePath,
-		httputil.MakeInternalAPI("performPasswordUpdate", func(req *http.Request) util.JSONResponse {
-			request := api.PerformPasswordUpdateRequest{}
-			response := api.PerformPasswordUpdateResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformPasswordUpdate(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformPasswordUpdatePath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformPasswordUpdate", s.PerformPasswordUpdate),
 	)
-	internalAPIMux.Handle(PerformDeviceCreationPath,
-		httputil.MakeInternalAPI("performDeviceCreation", func(req *http.Request) util.JSONResponse {
-			request := api.PerformDeviceCreationRequest{}
-			response := api.PerformDeviceCreationResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformDeviceCreation(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformDeviceCreationPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformDeviceCreation", s.PerformDeviceCreation),
 	)
-	internalAPIMux.Handle(PerformLastSeenUpdatePath,
-		httputil.MakeInternalAPI("performLastSeenUpdate", func(req *http.Request) util.JSONResponse {
-			request := api.PerformLastSeenUpdateRequest{}
-			response := api.PerformLastSeenUpdateResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformLastSeenUpdate(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformLastSeenUpdatePath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformLastSeenUpdate", s.PerformLastSeenUpdate),
 	)
-	internalAPIMux.Handle(PerformDeviceUpdatePath,
-		httputil.MakeInternalAPI("performDeviceUpdate", func(req *http.Request) util.JSONResponse {
-			request := api.PerformDeviceUpdateRequest{}
-			response := api.PerformDeviceUpdateResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformDeviceUpdate(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformDeviceUpdatePath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformDeviceUpdate", s.PerformDeviceUpdate),
 	)
-	internalAPIMux.Handle(PerformDeviceDeletionPath,
-		httputil.MakeInternalAPI("performDeviceDeletion", func(req *http.Request) util.JSONResponse {
-			request := api.PerformDeviceDeletionRequest{}
-			response := api.PerformDeviceDeletionResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformDeviceDeletion(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformDeviceDeletionPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformDeviceDeletion", s.PerformDeviceDeletion),
 	)
-	internalAPIMux.Handle(PerformAccountDeactivationPath,
-		httputil.MakeInternalAPI("performAccountDeactivation", func(req *http.Request) util.JSONResponse {
-			request := api.PerformAccountDeactivationRequest{}
-			response := api.PerformAccountDeactivationResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformAccountDeactivation(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformAccountDeactivationPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformAccountDeactivation", s.PerformAccountDeactivation),
 	)
-	internalAPIMux.Handle(PerformOpenIDTokenCreationPath,
-		httputil.MakeInternalAPI("performOpenIDTokenCreation", func(req *http.Request) util.JSONResponse {
-			request := api.PerformOpenIDTokenCreationRequest{}
-			response := api.PerformOpenIDTokenCreationResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformOpenIDTokenCreation(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformOpenIDTokenCreationPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformOpenIDTokenCreation", s.PerformOpenIDTokenCreation),
 	)
-	internalAPIMux.Handle(QueryProfilePath,
-		httputil.MakeInternalAPI("queryProfile", func(req *http.Request) util.JSONResponse {
-			request := api.QueryProfileRequest{}
-			response := api.QueryProfileResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryProfile(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryProfilePath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryProfile", s.QueryProfile),
 	)
-	internalAPIMux.Handle(QueryAccessTokenPath,
-		httputil.MakeInternalAPI("queryAccessToken", func(req *http.Request) util.JSONResponse {
-			request := api.QueryAccessTokenRequest{}
-			response := api.QueryAccessTokenResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryAccessToken(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryAccessTokenPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryAccessToken", s.QueryAccessToken),
 	)
-	internalAPIMux.Handle(QueryDevicesPath,
-		httputil.MakeInternalAPI("queryDevices", func(req *http.Request) util.JSONResponse {
-			request := api.QueryDevicesRequest{}
-			response := api.QueryDevicesResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryDevices(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryDevicesPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryDevices", s.QueryDevices),
 	)
-	internalAPIMux.Handle(QueryAccountDataPath,
-		httputil.MakeInternalAPI("queryAccountData", func(req *http.Request) util.JSONResponse {
-			request := api.QueryAccountDataRequest{}
-			response := api.QueryAccountDataResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryAccountData(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryAccountDataPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryAccountData", s.QueryAccountData),
 	)
-	internalAPIMux.Handle(QueryDeviceInfosPath,
-		httputil.MakeInternalAPI("queryDeviceInfos", func(req *http.Request) util.JSONResponse {
-			request := api.QueryDeviceInfosRequest{}
-			response := api.QueryDeviceInfosResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryDeviceInfos(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryDeviceInfosPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryDeviceInfos", s.QueryDeviceInfos),
 	)
-	internalAPIMux.Handle(QuerySearchProfilesPath,
-		httputil.MakeInternalAPI("querySearchProfiles", func(req *http.Request) util.JSONResponse {
-			request := api.QuerySearchProfilesRequest{}
-			response := api.QuerySearchProfilesResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QuerySearchProfiles(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QuerySearchProfilesPath,
+		httputil.MakeInternalRPCAPI("UserAPIQuerySearchProfiles", s.QuerySearchProfiles),
 	)
-	internalAPIMux.Handle(QueryOpenIDTokenPath,
-		httputil.MakeInternalAPI("queryOpenIDToken", func(req *http.Request) util.JSONResponse {
-			request := api.QueryOpenIDTokenRequest{}
-			response := api.QueryOpenIDTokenResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryOpenIDToken(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryOpenIDTokenPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryOpenIDToken", s.QueryOpenIDToken),
 	)
-	internalAPIMux.Handle(InputAccountDataPath,
-		httputil.MakeInternalAPI("inputAccountDataPath", func(req *http.Request) util.JSONResponse {
-			request := api.InputAccountDataRequest{}
-			response := api.InputAccountDataResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.InputAccountData(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		InputAccountDataPath,
+		httputil.MakeInternalRPCAPI("UserAPIInputAccountData", s.InputAccountData),
 	)
-	internalAPIMux.Handle(QueryKeyBackupPath,
-		httputil.MakeInternalAPI("queryKeyBackup", func(req *http.Request) util.JSONResponse {
-			request := api.QueryKeyBackupRequest{}
-			response := api.QueryKeyBackupResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			s.QueryKeyBackup(req.Context(), &request, &response)
-			if response.Error != "" {
-				return util.ErrorResponse(fmt.Errorf("QueryKeyBackup: %s", response.Error))
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryKeyBackupPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryKeyBackup", s.QueryKeyBackup),
 	)
-	internalAPIMux.Handle(PerformKeyBackupPath,
-		httputil.MakeInternalAPI("performKeyBackup", func(req *http.Request) util.JSONResponse {
-			request := api.PerformKeyBackupRequest{}
-			response := api.PerformKeyBackupResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			err := s.PerformKeyBackup(req.Context(), &request, &response)
-			if err != nil {
-				return util.JSONResponse{Code: http.StatusBadRequest, JSON: &response}
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformKeyBackupPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformKeyBackup", s.PerformKeyBackup),
 	)
-	internalAPIMux.Handle(QueryNotificationsPath,
-		httputil.MakeInternalAPI("queryNotifications", func(req *http.Request) util.JSONResponse {
-			var request api.QueryNotificationsRequest
-			var response api.QueryNotificationsResponse
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryNotifications(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryNotificationsPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryNotifications", s.QueryNotifications),
 	)
 
-	internalAPIMux.Handle(PerformPusherSetPath,
-		httputil.MakeInternalAPI("performPusherSet", func(req *http.Request) util.JSONResponse {
-			request := api.PerformPusherSetRequest{}
-			response := struct{}{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformPusherSet(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+	internalAPIMux.Handle(
+		PerformPusherSetPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformPusherSet", s.PerformPusherSet),
 	)
-	internalAPIMux.Handle(PerformPusherDeletionPath,
-		httputil.MakeInternalAPI("performPusherDeletion", func(req *http.Request) util.JSONResponse {
-			request := api.PerformPusherDeletionRequest{}
-			response := struct{}{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformPusherDeletion(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformPusherDeletionPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformPusherDeletion", s.PerformPusherDeletion),
 	)
 
-	internalAPIMux.Handle(QueryPushersPath,
-		httputil.MakeInternalAPI("queryPushers", func(req *http.Request) util.JSONResponse {
-			request := api.QueryPushersRequest{}
-			response := api.QueryPushersResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryPushers(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+	internalAPIMux.Handle(
+		QueryPushersPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryPushers", s.QueryPushers),
 	)
 
-	internalAPIMux.Handle(PerformPushRulesPutPath,
-		httputil.MakeInternalAPI("performPushRulesPut", func(req *http.Request) util.JSONResponse {
-			request := api.PerformPushRulesPutRequest{}
-			response := struct{}{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformPushRulesPut(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+	internalAPIMux.Handle(
+		PerformPushRulesPutPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformPushRulesPut", s.PerformPushRulesPut),
 	)
 
-	internalAPIMux.Handle(QueryPushRulesPath,
-		httputil.MakeInternalAPI("queryPushRules", func(req *http.Request) util.JSONResponse {
-			request := api.QueryPushRulesRequest{}
-			response := api.QueryPushRulesResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryPushRules(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+	internalAPIMux.Handle(
+		QueryPushRulesPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryPushRules", s.QueryPushRules),
 	)
-	internalAPIMux.Handle(PerformSetAvatarURLPath,
-		httputil.MakeInternalAPI("performSetAvatarURL", func(req *http.Request) util.JSONResponse {
-			request := api.PerformSetAvatarURLRequest{}
-			response := api.PerformSetAvatarURLResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.SetAvatarURL(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformSetAvatarURLPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformSetAvatarURL", s.SetAvatarURL),
 	)
+
+	// TODO: Look at the shape of this
 	internalAPIMux.Handle(QueryNumericLocalpartPath,
-		httputil.MakeInternalAPI("queryNumericLocalpart", func(req *http.Request) util.JSONResponse {
+		httputil.MakeInternalAPI("UserAPIQueryNumericLocalpart", func(req *http.Request) util.JSONResponse {
 			response := api.QueryNumericLocalpartResponse{}
 			if err := s.QueryNumericLocalpart(req.Context(), &response); err != nil {
 				return util.ErrorResponse(err)
@@ -369,92 +162,39 @@ func AddRoutes(internalAPIMux *mux.Router, s api.UserInternalAPI) {
 			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
 		}),
 	)
-	internalAPIMux.Handle(QueryAccountAvailabilityPath,
-		httputil.MakeInternalAPI("queryAccountAvailability", func(req *http.Request) util.JSONResponse {
-			request := api.QueryAccountAvailabilityRequest{}
-			response := api.QueryAccountAvailabilityResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryAccountAvailability(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryAccountAvailabilityPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryAccountAvailability", s.QueryAccountAvailability),
 	)
-	internalAPIMux.Handle(QueryAccountByPasswordPath,
-		httputil.MakeInternalAPI("queryAccountByPassword", func(req *http.Request) util.JSONResponse {
-			request := api.QueryAccountByPasswordRequest{}
-			response := api.QueryAccountByPasswordResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryAccountByPassword(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryAccountByPasswordPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryAccountByPassword", s.QueryAccountByPassword),
 	)
-	internalAPIMux.Handle(PerformSetDisplayNamePath,
-		httputil.MakeInternalAPI("performSetDisplayName", func(req *http.Request) util.JSONResponse {
-			request := api.PerformUpdateDisplayNameRequest{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.SetDisplayName(req.Context(), &request, &struct{}{}); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &struct{}{}}
-		}),
+
+	internalAPIMux.Handle(
+		PerformSetDisplayNamePath,
+		httputil.MakeInternalRPCAPI("UserAPISetDisplayName", s.SetDisplayName),
 	)
-	internalAPIMux.Handle(QueryLocalpartForThreePIDPath,
-		httputil.MakeInternalAPI("queryLocalpartForThreePID", func(req *http.Request) util.JSONResponse {
-			request := api.QueryLocalpartForThreePIDRequest{}
-			response := api.QueryLocalpartForThreePIDResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryLocalpartForThreePID(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryLocalpartForThreePIDPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryLocalpartForThreePID", s.QueryLocalpartForThreePID),
 	)
-	internalAPIMux.Handle(QueryThreePIDsForLocalpartPath,
-		httputil.MakeInternalAPI("queryThreePIDsForLocalpart", func(req *http.Request) util.JSONResponse {
-			request := api.QueryThreePIDsForLocalpartRequest{}
-			response := api.QueryThreePIDsForLocalpartResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryThreePIDsForLocalpart(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryThreePIDsForLocalpartPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryThreePIDsForLocalpart", s.QueryThreePIDsForLocalpart),
 	)
-	internalAPIMux.Handle(PerformForgetThreePIDPath,
-		httputil.MakeInternalAPI("performForgetThreePID", func(req *http.Request) util.JSONResponse {
-			request := api.PerformForgetThreePIDRequest{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformForgetThreePID(req.Context(), &request, &struct{}{}); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &struct{}{}}
-		}),
+
+	internalAPIMux.Handle(
+		PerformForgetThreePIDPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformForgetThreePID", s.PerformForgetThreePID),
 	)
-	internalAPIMux.Handle(PerformSaveThreePIDAssociationPath,
-		httputil.MakeInternalAPI("performSaveThreePIDAssociation", func(req *http.Request) util.JSONResponse {
-			request := api.PerformSaveThreePIDAssociationRequest{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformSaveThreePIDAssociation(req.Context(), &request, &struct{}{}); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &struct{}{}}
-		}),
+
+	internalAPIMux.Handle(
+		PerformSaveThreePIDAssociationPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformSaveThreePIDAssociation", s.PerformSaveThreePIDAssociation),
 	)
 }
diff --git a/userapi/inthttp/server_logintoken.go b/userapi/inthttp/server_logintoken.go
index 1f2eb34b..b5734841 100644
--- a/userapi/inthttp/server_logintoken.go
+++ b/userapi/inthttp/server_logintoken.go
@@ -15,54 +15,25 @@
 package inthttp
 
 import (
-	"encoding/json"
-	"net/http"
-
 	"github.com/gorilla/mux"
 	"github.com/matrix-org/dendrite/internal/httputil"
 	"github.com/matrix-org/dendrite/userapi/api"
-	"github.com/matrix-org/util"
 )
 
 // addRoutesLoginToken adds routes for all login token API calls.
 func addRoutesLoginToken(internalAPIMux *mux.Router, s api.UserInternalAPI) {
-	internalAPIMux.Handle(PerformLoginTokenCreationPath,
-		httputil.MakeInternalAPI("performLoginTokenCreation", func(req *http.Request) util.JSONResponse {
-			request := api.PerformLoginTokenCreationRequest{}
-			response := api.PerformLoginTokenCreationResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformLoginTokenCreation(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+	internalAPIMux.Handle(
+		PerformLoginTokenCreationPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformLoginTokenCreation", s.PerformLoginTokenCreation),
 	)
-	internalAPIMux.Handle(PerformLoginTokenDeletionPath,
-		httputil.MakeInternalAPI("performLoginTokenDeletion", func(req *http.Request) util.JSONResponse {
-			request := api.PerformLoginTokenDeletionRequest{}
-			response := api.PerformLoginTokenDeletionResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.PerformLoginTokenDeletion(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		PerformLoginTokenDeletionPath,
+		httputil.MakeInternalRPCAPI("UserAPIPerformLoginTokenDeletion", s.PerformLoginTokenDeletion),
 	)
-	internalAPIMux.Handle(QueryLoginTokenPath,
-		httputil.MakeInternalAPI("queryLoginToken", func(req *http.Request) util.JSONResponse {
-			request := api.QueryLoginTokenRequest{}
-			response := api.QueryLoginTokenResponse{}
-			if err := json.NewDecoder(req.Body).Decode(&request); err != nil {
-				return util.MessageResponse(http.StatusBadRequest, err.Error())
-			}
-			if err := s.QueryLoginToken(req.Context(), &request, &response); err != nil {
-				return util.ErrorResponse(err)
-			}
-			return util.JSONResponse{Code: http.StatusOK, JSON: &response}
-		}),
+
+	internalAPIMux.Handle(
+		QueryLoginTokenPath,
+		httputil.MakeInternalRPCAPI("UserAPIQueryLoginToken", s.QueryLoginToken),
 	)
 }
diff --git a/userapi/userapi_test.go b/userapi/userapi_test.go
index 40e37c5d..31a69793 100644
--- a/userapi/userapi_test.go
+++ b/userapi/userapi_test.go
@@ -117,16 +117,20 @@ func TestQueryProfile(t *testing.T) {
 		},
 	}
 
-	runCases := func(testAPI api.UserInternalAPI) {
+	runCases := func(testAPI api.UserInternalAPI, http bool) {
+		mode := "monolith"
+		if http {
+			mode = "HTTP"
+		}
 		for _, tc := range testCases {
 			var gotRes api.QueryProfileResponse
 			gotErr := testAPI.QueryProfile(context.TODO(), &tc.req, &gotRes)
 			if tc.wantErr == nil && gotErr != nil || tc.wantErr != nil && gotErr == nil {
-				t.Errorf("QueryProfile error, got %s want %s", gotErr, tc.wantErr)
+				t.Errorf("QueryProfile %s error, got %s want %s", mode, gotErr, tc.wantErr)
 				continue
 			}
 			if !reflect.DeepEqual(tc.wantRes, gotRes) {
-				t.Errorf("QueryProfile response got %+v want %+v", gotRes, tc.wantRes)
+				t.Errorf("QueryProfile %s response got %+v want %+v", mode, gotRes, tc.wantRes)
 			}
 		}
 	}
@@ -140,10 +144,10 @@ func TestQueryProfile(t *testing.T) {
 		if err != nil {
 			t.Fatalf("failed to create HTTP client")
 		}
-		runCases(httpAPI)
+		runCases(httpAPI, true)
 	})
 	t.Run("Monolith", func(t *testing.T) {
-		runCases(userAPI)
+		runCases(userAPI, false)
 	})
 }