Chore: Remove result field from stats (#65166)

remove result field from stats

pkg/api/admin.go

@@ -46,13 +46,12 @@ func (hs *HTTPServer) AdminGetSettings(c *contextmodel.ReqContext) response.Resp
 // 403: forbiddenError
 // 500: internalServerError
 func (hs *HTTPServer) AdminGetStats(c *contextmodel.ReqContext) response.Response {
-	statsQuery := stats.GetAdminStatsQuery{}
+	adminStats, err := hs.statsService.GetAdminStats(c.Req.Context(), &stats.GetAdminStatsQuery{})
-
+	if err != nil {
-	if err := hs.statsService.GetAdminStats(c.Req.Context(), &statsQuery); err != nil {
 		return response.Error(500, "Failed to get admin stats from database", err)
 	}
 
-	return response.JSON(http.StatusOK, statsQuery.Result)
+	return response.JSON(http.StatusOK, adminStats)
 }
 
 func (hs *HTTPServer) getAuthorizedSettings(ctx context.Context, user *user.SignedInUser, bag setting.SettingsBag) (setting.SettingsBag, error) {

pkg/infra/usagestats/statscollector/service.go

@@ -110,56 +110,56 @@ func (s *Service) Run(ctx context.Context) error {
 func (s *Service) collectSystemStats(ctx context.Context) (map[string]interface{}, error) {
 	m := map[string]interface{}{}
 
-	statsQuery := stats.GetSystemStatsQuery{}
+	statsResult, err := s.statsService.GetSystemStats(ctx, &stats.GetSystemStatsQuery{})
-	if err := s.statsService.GetSystemStats(ctx, &statsQuery); err != nil {
+	if err != nil {
 		s.log.Error("Failed to get system stats", "error", err)
 		return nil, err
 	}
 
-	m["stats.dashboards.count"] = statsQuery.Result.Dashboards
+	m["stats.dashboards.count"] = statsResult.Dashboards
-	m["stats.users.count"] = statsQuery.Result.Users
+	m["stats.users.count"] = statsResult.Users
-	m["stats.admins.count"] = statsQuery.Result.Admins
+	m["stats.admins.count"] = statsResult.Admins
-	m["stats.editors.count"] = statsQuery.Result.Editors
+	m["stats.editors.count"] = statsResult.Editors
-	m["stats.viewers.count"] = statsQuery.Result.Viewers
+	m["stats.viewers.count"] = statsResult.Viewers
-	m["stats.orgs.count"] = statsQuery.Result.Orgs
+	m["stats.orgs.count"] = statsResult.Orgs
-	m["stats.playlist.count"] = statsQuery.Result.Playlists
+	m["stats.playlist.count"] = statsResult.Playlists
 	m["stats.plugins.apps.count"] = s.appCount(ctx)
 	m["stats.plugins.panels.count"] = s.panelCount(ctx)
 	m["stats.plugins.datasources.count"] = s.dataSourceCount(ctx)
-	m["stats.alerts.count"] = statsQuery.Result.Alerts
+	m["stats.alerts.count"] = statsResult.Alerts
-	m["stats.active_users.count"] = statsQuery.Result.ActiveUsers
+	m["stats.active_users.count"] = statsResult.ActiveUsers
-	m["stats.active_admins.count"] = statsQuery.Result.ActiveAdmins
+	m["stats.active_admins.count"] = statsResult.ActiveAdmins
-	m["stats.active_editors.count"] = statsQuery.Result.ActiveEditors
+	m["stats.active_editors.count"] = statsResult.ActiveEditors
-	m["stats.active_viewers.count"] = statsQuery.Result.ActiveViewers
+	m["stats.active_viewers.count"] = statsResult.ActiveViewers
-	m["stats.active_sessions.count"] = statsQuery.Result.ActiveSessions
+	m["stats.active_sessions.count"] = statsResult.ActiveSessions
-	m["stats.monthly_active_users.count"] = statsQuery.Result.MonthlyActiveUsers
+	m["stats.monthly_active_users.count"] = statsResult.MonthlyActiveUsers
-	m["stats.daily_active_users.count"] = statsQuery.Result.DailyActiveUsers
+	m["stats.daily_active_users.count"] = statsResult.DailyActiveUsers
-	m["stats.daily_active_admins.count"] = statsQuery.Result.DailyActiveAdmins
+	m["stats.daily_active_admins.count"] = statsResult.DailyActiveAdmins
-	m["stats.daily_active_editors.count"] = statsQuery.Result.DailyActiveEditors
+	m["stats.daily_active_editors.count"] = statsResult.DailyActiveEditors
-	m["stats.daily_active_viewers.count"] = statsQuery.Result.DailyActiveViewers
+	m["stats.daily_active_viewers.count"] = statsResult.DailyActiveViewers
-	m["stats.daily_active_sessions.count"] = statsQuery.Result.DailyActiveSessions
+	m["stats.daily_active_sessions.count"] = statsResult.DailyActiveSessions
-	m["stats.datasources.count"] = statsQuery.Result.Datasources
+	m["stats.datasources.count"] = statsResult.Datasources
-	m["stats.stars.count"] = statsQuery.Result.Stars
+	m["stats.stars.count"] = statsResult.Stars
-	m["stats.folders.count"] = statsQuery.Result.Folders
+	m["stats.folders.count"] = statsResult.Folders
-	m["stats.dashboard_permissions.count"] = statsQuery.Result.DashboardPermissions
+	m["stats.dashboard_permissions.count"] = statsResult.DashboardPermissions
-	m["stats.folder_permissions.count"] = statsQuery.Result.FolderPermissions
+	m["stats.folder_permissions.count"] = statsResult.FolderPermissions
-	m["stats.provisioned_dashboards.count"] = statsQuery.Result.ProvisionedDashboards
+	m["stats.provisioned_dashboards.count"] = statsResult.ProvisionedDashboards
-	m["stats.snapshots.count"] = statsQuery.Result.Snapshots
+	m["stats.snapshots.count"] = statsResult.Snapshots
-	m["stats.teams.count"] = statsQuery.Result.Teams
+	m["stats.teams.count"] = statsResult.Teams
-	m["stats.total_auth_token.count"] = statsQuery.Result.AuthTokens
+	m["stats.total_auth_token.count"] = statsResult.AuthTokens
-	m["stats.dashboard_versions.count"] = statsQuery.Result.DashboardVersions
+	m["stats.dashboard_versions.count"] = statsResult.DashboardVersions
-	m["stats.annotations.count"] = statsQuery.Result.Annotations
+	m["stats.annotations.count"] = statsResult.Annotations
-	m["stats.alert_rules.count"] = statsQuery.Result.AlertRules
+	m["stats.alert_rules.count"] = statsResult.AlertRules
-	m["stats.library_panels.count"] = statsQuery.Result.LibraryPanels
+	m["stats.library_panels.count"] = statsResult.LibraryPanels
-	m["stats.library_variables.count"] = statsQuery.Result.LibraryVariables
+	m["stats.library_variables.count"] = statsResult.LibraryVariables
-	m["stats.dashboards_viewers_can_edit.count"] = statsQuery.Result.DashboardsViewersCanEdit
+	m["stats.dashboards_viewers_can_edit.count"] = statsResult.DashboardsViewersCanEdit
-	m["stats.dashboards_viewers_can_admin.count"] = statsQuery.Result.DashboardsViewersCanAdmin
+	m["stats.dashboards_viewers_can_admin.count"] = statsResult.DashboardsViewersCanAdmin
-	m["stats.folders_viewers_can_edit.count"] = statsQuery.Result.FoldersViewersCanEdit
+	m["stats.folders_viewers_can_edit.count"] = statsResult.FoldersViewersCanEdit
-	m["stats.folders_viewers_can_admin.count"] = statsQuery.Result.FoldersViewersCanAdmin
+	m["stats.folders_viewers_can_admin.count"] = statsResult.FoldersViewersCanAdmin
-	m["stats.api_keys.count"] = statsQuery.Result.APIKeys
+	m["stats.api_keys.count"] = statsResult.APIKeys
-	m["stats.data_keys.count"] = statsQuery.Result.DataKeys
+	m["stats.data_keys.count"] = statsResult.DataKeys
-	m["stats.active_data_keys.count"] = statsQuery.Result.ActiveDataKeys
+	m["stats.active_data_keys.count"] = statsResult.ActiveDataKeys
-	m["stats.public_dashboards.count"] = statsQuery.Result.PublicDashboards
+	m["stats.public_dashboards.count"] = statsResult.PublicDashboards
 
 	ossEditionCount := 1
 	enterpriseEditionCount := 0
@@ -170,8 +170,8 @@ func (s *Service) collectSystemStats(ctx context.Context) (map[string]interface{
 	m["stats.edition.oss.count"] = ossEditionCount
 	m["stats.edition.enterprise.count"] = enterpriseEditionCount
 
-	userCount := statsQuery.Result.Users
+	userCount := statsResult.Users
-	avgAuthTokensPerUser := statsQuery.Result.AuthTokens
+	avgAuthTokensPerUser := statsResult.AuthTokens
 	if userCount != 0 {
 		avgAuthTokensPerUser /= userCount
 	}
@@ -204,13 +204,13 @@ func (s *Service) collectAdditionalMetrics(ctx context.Context) (map[string]inte
 func (s *Service) collectAlertNotifierStats(ctx context.Context) (map[string]interface{}, error) {
 	m := map[string]interface{}{}
 	// get stats about alert notifier usage
-	anStats := stats.GetAlertNotifierUsageStatsQuery{}
+	anResult, err := s.statsService.GetAlertNotifiersUsageStats(ctx, &stats.GetAlertNotifierUsageStatsQuery{})
-	if err := s.statsService.GetAlertNotifiersUsageStats(ctx, &anStats); err != nil {
+	if err != nil {
 		s.log.Error("Failed to get alert notification stats", "error", err)
 		return nil, err
 	}
 
-	for _, stats := range anStats.Result {
+	for _, stats := range anResult {
 		m["stats.alert_notifiers."+stats.Type+".count"] = stats.Count
 	}
 	return m, nil
@@ -218,8 +218,8 @@ func (s *Service) collectAlertNotifierStats(ctx context.Context) (map[string]int
 
 func (s *Service) collectDatasourceStats(ctx context.Context) (map[string]interface{}, error) {
 	m := map[string]interface{}{}
-	dsStats := stats.GetDataSourceStatsQuery{}
+	dsResult, err := s.statsService.GetDataSourceStats(ctx, &stats.GetDataSourceStatsQuery{})
-	if err := s.statsService.GetDataSourceStats(ctx, &dsStats); err != nil {
+	if err != nil {
 		s.log.Error("Failed to get datasource stats", "error", err)
 		return nil, err
 	}
@@ -228,7 +228,7 @@ func (s *Service) collectDatasourceStats(ctx context.Context) (map[string]interf
 	// but ignore any custom data sources
 	// as sending that name could be sensitive information
 	dsOtherCount := 0
-	for _, dsStat := range dsStats.Result {
+	for _, dsStat := range dsResult {
 		if s.validator.ShouldBeReported(ctx, dsStat.Type) {
 			m["stats.ds."+dsStat.Type+".count"] = dsStat.Count
 		} else {
@@ -266,8 +266,8 @@ func (s *Service) collectDatasourceAccess(ctx context.Context) (map[string]inter
 	m := map[string]interface{}{}
 
 	// fetch datasource access stats
-	dsAccessStats := stats.GetDataSourceAccessStatsQuery{}
+	dsAccessResult, err := s.statsService.GetDataSourceAccessStats(ctx, &stats.GetDataSourceAccessStatsQuery{})
-	if err := s.statsService.GetDataSourceAccessStats(ctx, &dsAccessStats); err != nil {
+	if err != nil {
 		s.log.Error("Failed to get datasource access stats", "error", err)
 		return nil, err
 	}
@@ -276,7 +276,7 @@ func (s *Service) collectDatasourceAccess(ctx context.Context) (map[string]inter
 	// but ignore any custom data sources
 	// as sending that name could be sensitive information
 	dsAccessOtherCount := make(map[string]int64)
-	for _, dsAccessStat := range dsAccessStats.Result {
+	for _, dsAccessStat := range dsAccessResult {
 		if dsAccessStat.Access == "" {
 			continue
 		}
@@ -302,49 +302,49 @@ func (s *Service) updateTotalStats(ctx context.Context) bool {
 		return false
 	}
 
-	statsQuery := stats.GetSystemStatsQuery{}
+	statsResult, err := s.statsService.GetSystemStats(ctx, &stats.GetSystemStatsQuery{})
-	if err := s.statsService.GetSystemStats(ctx, &statsQuery); err != nil {
+	if err != nil {
 		s.log.Error("Failed to get system stats", "error", err)
 		return false
 	}
 
-	if statsQuery.Result == nil {
+	if statsResult == nil {
 		s.log.Error("Cannot retrieve system stats")
 		return false
 	}
 
-	metrics.MStatTotalDashboards.Set(float64(statsQuery.Result.Dashboards))
+	metrics.MStatTotalDashboards.Set(float64(statsResult.Dashboards))
-	metrics.MStatTotalFolders.Set(float64(statsQuery.Result.Folders))
+	metrics.MStatTotalFolders.Set(float64(statsResult.Folders))
-	metrics.MStatTotalUsers.Set(float64(statsQuery.Result.Users))
+	metrics.MStatTotalUsers.Set(float64(statsResult.Users))
-	metrics.MStatTotalTeams.Set(float64(statsQuery.Result.Teams))
+	metrics.MStatTotalTeams.Set(float64(statsResult.Teams))
-	metrics.MStatActiveUsers.Set(float64(statsQuery.Result.ActiveUsers))
+	metrics.MStatActiveUsers.Set(float64(statsResult.ActiveUsers))
-	metrics.MStatTotalPlaylists.Set(float64(statsQuery.Result.Playlists))
+	metrics.MStatTotalPlaylists.Set(float64(statsResult.Playlists))
-	metrics.MStatTotalOrgs.Set(float64(statsQuery.Result.Orgs))
+	metrics.MStatTotalOrgs.Set(float64(statsResult.Orgs))
-	metrics.StatsTotalViewers.Set(float64(statsQuery.Result.Viewers))
+	metrics.StatsTotalViewers.Set(float64(statsResult.Viewers))
-	metrics.StatsTotalActiveViewers.Set(float64(statsQuery.Result.ActiveViewers))
+	metrics.StatsTotalActiveViewers.Set(float64(statsResult.ActiveViewers))
-	metrics.StatsTotalEditors.Set(float64(statsQuery.Result.Editors))
+	metrics.StatsTotalEditors.Set(float64(statsResult.Editors))
-	metrics.StatsTotalActiveEditors.Set(float64(statsQuery.Result.ActiveEditors))
+	metrics.StatsTotalActiveEditors.Set(float64(statsResult.ActiveEditors))
-	metrics.StatsTotalAdmins.Set(float64(statsQuery.Result.Admins))
+	metrics.StatsTotalAdmins.Set(float64(statsResult.Admins))
-	metrics.StatsTotalActiveAdmins.Set(float64(statsQuery.Result.ActiveAdmins))
+	metrics.StatsTotalActiveAdmins.Set(float64(statsResult.ActiveAdmins))
-	metrics.StatsTotalDashboardVersions.Set(float64(statsQuery.Result.DashboardVersions))
+	metrics.StatsTotalDashboardVersions.Set(float64(statsResult.DashboardVersions))
-	metrics.StatsTotalAnnotations.Set(float64(statsQuery.Result.Annotations))
+	metrics.StatsTotalAnnotations.Set(float64(statsResult.Annotations))
-	metrics.StatsTotalAlertRules.Set(float64(statsQuery.Result.AlertRules))
+	metrics.StatsTotalAlertRules.Set(float64(statsResult.AlertRules))
-	metrics.StatsTotalLibraryPanels.Set(float64(statsQuery.Result.LibraryPanels))
+	metrics.StatsTotalLibraryPanels.Set(float64(statsResult.LibraryPanels))
-	metrics.StatsTotalLibraryVariables.Set(float64(statsQuery.Result.LibraryVariables))
+	metrics.StatsTotalLibraryVariables.Set(float64(statsResult.LibraryVariables))
 
-	metrics.StatsTotalDataKeys.With(prometheus.Labels{"active": "true"}).Set(float64(statsQuery.Result.ActiveDataKeys))
+	metrics.StatsTotalDataKeys.With(prometheus.Labels{"active": "true"}).Set(float64(statsResult.ActiveDataKeys))
-	inactiveDataKeys := statsQuery.Result.DataKeys - statsQuery.Result.ActiveDataKeys
+	inactiveDataKeys := statsResult.DataKeys - statsResult.ActiveDataKeys
 	metrics.StatsTotalDataKeys.With(prometheus.Labels{"active": "false"}).Set(float64(inactiveDataKeys))
 
-	metrics.MStatTotalPublicDashboards.Set(float64(statsQuery.Result.PublicDashboards))
+	metrics.MStatTotalPublicDashboards.Set(float64(statsResult.PublicDashboards))
 
-	dsStats := stats.GetDataSourceStatsQuery{}
+	dsResult, err := s.statsService.GetDataSourceStats(ctx, &stats.GetDataSourceStatsQuery{})
-	if err := s.statsService.GetDataSourceStats(ctx, &dsStats); err != nil {
+	if err != nil {
 		s.log.Error("Failed to get datasource stats", "error", err)
 		return true
 	}
 
-	for _, dsStat := range dsStats.Result {
+	for _, dsStat := range dsResult {
 		metrics.StatsTotalDataSources.WithLabelValues(dsStat.Type).Set(float64(dsStat.Count))
 	}
 	return true

pkg/services/stats/models.go

@@ -49,13 +49,9 @@ type DataSourceStats struct {
 	Type  string
 }
 
-type GetSystemStatsQuery struct {
+type GetSystemStatsQuery struct{}
-	Result *SystemStats
-}
 
-type GetDataSourceStatsQuery struct {
+type GetDataSourceStatsQuery struct{}
-	Result []*DataSourceStats
-}
 
 type DataSourceAccessStats struct {
 	Type   string
@@ -63,18 +59,14 @@ type DataSourceAccessStats struct {
 	Count  int64
 }
 
-type GetDataSourceAccessStatsQuery struct {
+type GetDataSourceAccessStatsQuery struct{}
-	Result []*DataSourceAccessStats
-}
 
 type NotifierUsageStats struct {
 	Type  string
 	Count int64
 }
 
-type GetAlertNotifierUsageStatsQuery struct {
+type GetAlertNotifierUsageStatsQuery struct{}
-	Result []*NotifierUsageStats
-}
 
 type AdminStats struct {
 	Orgs                int64 `json:"orgs"`
@@ -102,17 +94,13 @@ type AdminStats struct {
 	MonthlyActiveUsers  int64 `json:"monthlyActiveUsers"`
 }
 
-type GetAdminStatsQuery struct {
+type GetAdminStatsQuery struct{}
-	Result *AdminStats
-}
 
 type SystemUserCountStats struct {
 	Count int64
 }
 
-type GetSystemUserCountStatsQuery struct {
+type GetSystemUserCountStatsQuery struct{}
-	Result *SystemUserCountStats
-}
 
 type UserStats struct {
 	Users   int64

pkg/services/stats/stats.go

@@ -5,10 +5,10 @@ import (
 )
 
 type Service interface {
-	GetAdminStats(ctx context.Context, query *GetAdminStatsQuery) error
+	GetAdminStats(ctx context.Context, query *GetAdminStatsQuery) (*AdminStats, error)
-	GetAlertNotifiersUsageStats(ctx context.Context, query *GetAlertNotifierUsageStatsQuery) error
+	GetAlertNotifiersUsageStats(ctx context.Context, query *GetAlertNotifierUsageStatsQuery) ([]*NotifierUsageStats, error)
-	GetDataSourceStats(ctx context.Context, query *GetDataSourceStatsQuery) error
+	GetDataSourceStats(ctx context.Context, query *GetDataSourceStatsQuery) ([]*DataSourceStats, error)
-	GetDataSourceAccessStats(ctx context.Context, query *GetDataSourceAccessStatsQuery) error
+	GetDataSourceAccessStats(ctx context.Context, query *GetDataSourceAccessStatsQuery) ([]*DataSourceAccessStats, error)
-	GetSystemStats(ctx context.Context, query *GetSystemStatsQuery) error
+	GetSystemStats(ctx context.Context, query *GetSystemStatsQuery) (*SystemStats, error)
-	GetSystemUserCountStats(ctx context.Context, query *GetSystemUserCountStatsQuery) error
+	GetSystemUserCountStats(ctx context.Context, query *GetSystemUserCountStatsQuery) (*SystemUserCountStats, error)
 }

pkg/services/stats/statsimpl/stats.go

@@ -27,31 +27,34 @@ type sqlStatsService struct {
 	cfg *setting.Cfg
 }
 
-func (ss *sqlStatsService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) error {
+func (ss *sqlStatsService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) (result []*stats.NotifierUsageStats, err error) {
-	return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
+	err = ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
 		var rawSQL = `SELECT COUNT(*) AS count, type FROM ` + ss.db.GetDialect().Quote("alert_notification") + ` GROUP BY type`
-		query.Result = make([]*stats.NotifierUsageStats, 0)
+		result = make([]*stats.NotifierUsageStats, 0)
-		err := dbSession.SQL(rawSQL).Find(&query.Result)
+		err := dbSession.SQL(rawSQL).Find(&result)
 		return err
 	})
+	return result, err
 }
 
-func (ss *sqlStatsService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) error {
+func (ss *sqlStatsService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) (result []*stats.DataSourceStats, err error) {
-	return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
+	err = ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
 		var rawSQL = `SELECT COUNT(*) AS count, type FROM ` + ss.db.GetDialect().Quote("data_source") + ` GROUP BY type`
-		query.Result = make([]*stats.DataSourceStats, 0)
+		result = make([]*stats.DataSourceStats, 0)
-		err := dbSession.SQL(rawSQL).Find(&query.Result)
+		err := dbSession.SQL(rawSQL).Find(&result)
 		return err
 	})
+	return result, err
 }
 
-func (ss *sqlStatsService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) error {
+func (ss *sqlStatsService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) (result []*stats.DataSourceAccessStats, err error) {
-	return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
+	err = ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
 		var rawSQL = `SELECT COUNT(*) AS count, type, access FROM ` + ss.db.GetDialect().Quote("data_source") + ` GROUP BY type, access`
-		query.Result = make([]*stats.DataSourceAccessStats, 0)
+		result = make([]*stats.DataSourceAccessStats, 0)
-		err := dbSession.SQL(rawSQL).Find(&query.Result)
+		err := dbSession.SQL(rawSQL).Find(&result)
 		return err
 	})
+	return result, err
 }
 
 func notServiceAccount(dialect migrator.Dialect) string {
@@ -59,8 +62,8 @@ func notServiceAccount(dialect migrator.Dialect) string {
 		dialect.BooleanStr(false)
 }
 
-func (ss *sqlStatsService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) error {
+func (ss *sqlStatsService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) (result *stats.SystemStats, err error) {
-	return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
+	err = ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
 		sb := &db.SQLBuilder{}
 		sb.Write("SELECT ")
 		dialect := ss.db.GetDialect()
@@ -132,10 +135,11 @@ func (ss *sqlStatsService) GetSystemStats(ctx context.Context, query *stats.GetS
 			return err
 		}
 
-		query.Result = &stats
+		result = &stats
 
 		return nil
 	})
+	return result, err
 }
 
 func (ss *sqlStatsService) roleCounterSQL(ctx context.Context) string {
@@ -170,8 +174,8 @@ func viewersPermissionsCounterSQL(db db.DB, statName string, isFolder bool, perm
 	) AS ` + statName + `, `
 }
 
-func (ss *sqlStatsService) GetAdminStats(ctx context.Context, query *stats.GetAdminStatsQuery) error {
+func (ss *sqlStatsService) GetAdminStats(ctx context.Context, query *stats.GetAdminStatsQuery) (result *stats.AdminStats, err error) {
-	return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
+	err = ss.db.WithDbSession(ctx, func(dbSession *db.Session) error {
 		dialect := ss.db.GetDialect()
 		now := time.Now()
 		activeEndDate := now.Add(-activeUserTimeLimit)
@@ -245,13 +249,14 @@ func (ss *sqlStatsService) GetAdminStats(ctx context.Context, query *stats.GetAd
 			return err
 		}
 
-		query.Result = &stats
+		result = &stats
 		return nil
 	})
+	return result, err
 }
 
-func (ss *sqlStatsService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) error {
+func (ss *sqlStatsService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) (result *stats.SystemUserCountStats, err error) {
-	return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
+	err = ss.db.WithDbSession(ctx, func(sess *db.Session) error {
 		var rawSQL = `SELECT COUNT(id) AS Count FROM ` + ss.db.GetDialect().Quote("user")
 		var stats stats.SystemUserCountStats
 		_, err := sess.SQL(rawSQL).Get(&stats)
@@ -259,10 +264,11 @@ func (ss *sqlStatsService) GetSystemUserCountStats(ctx context.Context, query *s
 			return err
 		}
 
-		query.Result = &stats
+		result = &stats
 
 		return nil
 	})
+	return result, err
 }
 
 func (ss *sqlStatsService) IsUnifiedAlertingEnabled() bool {

pkg/services/stats/statsimpl/stats_test.go

@@ -29,44 +29,44 @@ func TestIntegrationStatsDataAccess(t *testing.T) {
 
 	t.Run("Get system stats should not results in error", func(t *testing.T) {
 		query := stats.GetSystemStatsQuery{}
-		err := statsService.GetSystemStats(context.Background(), &query)
+		result, err := statsService.GetSystemStats(context.Background(), &query)
 		require.NoError(t, err)
-		assert.Equal(t, int64(3), query.Result.Users)
+		assert.Equal(t, int64(3), result.Users)
-		assert.Equal(t, int64(0), query.Result.Editors)
+		assert.Equal(t, int64(0), result.Editors)
-		assert.Equal(t, int64(0), query.Result.Viewers)
+		assert.Equal(t, int64(0), result.Viewers)
-		assert.Equal(t, int64(3), query.Result.Admins)
+		assert.Equal(t, int64(3), result.Admins)
-		assert.Equal(t, int64(0), query.Result.LibraryPanels)
+		assert.Equal(t, int64(0), result.LibraryPanels)
-		assert.Equal(t, int64(0), query.Result.LibraryVariables)
+		assert.Equal(t, int64(0), result.LibraryVariables)
-		assert.Equal(t, int64(0), query.Result.APIKeys)
+		assert.Equal(t, int64(0), result.APIKeys)
 	})
 
 	t.Run("Get system user count stats should not results in error", func(t *testing.T) {
 		query := stats.GetSystemUserCountStatsQuery{}
-		err := statsService.GetSystemUserCountStats(context.Background(), &query)
+		_, err := statsService.GetSystemUserCountStats(context.Background(), &query)
 		assert.NoError(t, err)
 	})
 
 	t.Run("Get datasource stats should not results in error", func(t *testing.T) {
 		query := stats.GetDataSourceStatsQuery{}
-		err := statsService.GetDataSourceStats(context.Background(), &query)
+		_, err := statsService.GetDataSourceStats(context.Background(), &query)
 		assert.NoError(t, err)
 	})
 
 	t.Run("Get datasource access stats should not results in error", func(t *testing.T) {
 		query := stats.GetDataSourceAccessStatsQuery{}
-		err := statsService.GetDataSourceAccessStats(context.Background(), &query)
+		_, err := statsService.GetDataSourceAccessStats(context.Background(), &query)
 		assert.NoError(t, err)
 	})
 
 	t.Run("Get alert notifier stats should not results in error", func(t *testing.T) {
 		query := stats.GetAlertNotifierUsageStatsQuery{}
-		err := statsService.GetAlertNotifiersUsageStats(context.Background(), &query)
+		_, err := statsService.GetAlertNotifiersUsageStats(context.Background(), &query)
 		assert.NoError(t, err)
 	})
 
 	t.Run("Get admin stats should not result in error", func(t *testing.T) {
 		query := stats.GetAdminStatsQuery{}
-		err := statsService.GetAdminStats(context.Background(), &query)
+		_, err := statsService.GetAdminStats(context.Background(), &query)
 		assert.NoError(t, err)
 	})
 }
@@ -126,6 +126,6 @@ func TestIntegration_GetAdminStats(t *testing.T) {
 	statsService := ProvideService(&setting.Cfg{}, db)
 
 	query := stats.GetAdminStatsQuery{}
-	err := statsService.GetAdminStats(context.Background(), &query)
+	_, err := statsService.GetAdminStats(context.Background(), &query)
 	require.NoError(t, err)
 }

pkg/services/stats/statstest/stats.go

@@ -19,30 +19,26 @@ func NewFakeService() *FakeService {
 	return &FakeService{}
 }
 
-func (s *FakeService) GetAdminStats(ctx context.Context, query *stats.GetAdminStatsQuery) error {
+func (s *FakeService) GetAdminStats(ctx context.Context, query *stats.GetAdminStatsQuery) (*stats.AdminStats, error) {
-	return s.ExpectedError
+	return nil, s.ExpectedError
 }
 
-func (s *FakeService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) error {
+func (s *FakeService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) ([]*stats.NotifierUsageStats, error) {
-	query.Result = s.ExpectedNotifierUsageStats
+	return s.ExpectedNotifierUsageStats, s.ExpectedError
-	return s.ExpectedError
 }
 
-func (s *FakeService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) error {
+func (s *FakeService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) ([]*stats.DataSourceStats, error) {
-	query.Result = s.ExpectedDataSourceStats
+	return s.ExpectedDataSourceStats, s.ExpectedError
-	return s.ExpectedError
 }
 
-func (s *FakeService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) error {
+func (s *FakeService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) ([]*stats.DataSourceAccessStats, error) {
-	query.Result = s.ExpectedDataSourcesAccessStats
+	return s.ExpectedDataSourcesAccessStats, s.ExpectedError
-	return s.ExpectedError
 }
 
-func (s *FakeService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) error {
+func (s *FakeService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) (*stats.SystemStats, error) {
-	query.Result = s.ExpectedSystemStats
+	return s.ExpectedSystemStats, s.ExpectedError
-	return s.ExpectedError
 }
 
-func (s *FakeService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) error {
+func (s *FakeService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) (*stats.SystemUserCountStats, error) {
-	return s.ExpectedError
+	return nil, s.ExpectedError
 }