diff --git a/pkg/api/admin.go b/pkg/api/admin.go index 19ea7269cbf..e85ca94c572 100644 --- a/pkg/api/admin.go +++ b/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{} - - if err := hs.statsService.GetAdminStats(c.Req.Context(), &statsQuery); err != nil { + adminStats, err := hs.statsService.GetAdminStats(c.Req.Context(), &stats.GetAdminStatsQuery{}) + if 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) { diff --git a/pkg/infra/usagestats/statscollector/service.go b/pkg/infra/usagestats/statscollector/service.go index d14b15fef10..07db5905bb6 100644 --- a/pkg/infra/usagestats/statscollector/service.go +++ b/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{} - if err := s.statsService.GetSystemStats(ctx, &statsQuery); err != nil { + statsResult, err := s.statsService.GetSystemStats(ctx, &stats.GetSystemStatsQuery{}) + 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.users.count"] = statsQuery.Result.Users - m["stats.admins.count"] = statsQuery.Result.Admins - m["stats.editors.count"] = statsQuery.Result.Editors - m["stats.viewers.count"] = statsQuery.Result.Viewers - m["stats.orgs.count"] = statsQuery.Result.Orgs - m["stats.playlist.count"] = statsQuery.Result.Playlists + m["stats.dashboards.count"] = statsResult.Dashboards + m["stats.users.count"] = statsResult.Users + m["stats.admins.count"] = statsResult.Admins + m["stats.editors.count"] = statsResult.Editors + m["stats.viewers.count"] = statsResult.Viewers + m["stats.orgs.count"] = statsResult.Orgs + 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.active_users.count"] = statsQuery.Result.ActiveUsers - m["stats.active_admins.count"] = statsQuery.Result.ActiveAdmins - m["stats.active_editors.count"] = statsQuery.Result.ActiveEditors - m["stats.active_viewers.count"] = statsQuery.Result.ActiveViewers - m["stats.active_sessions.count"] = statsQuery.Result.ActiveSessions - m["stats.monthly_active_users.count"] = statsQuery.Result.MonthlyActiveUsers - m["stats.daily_active_users.count"] = statsQuery.Result.DailyActiveUsers - m["stats.daily_active_admins.count"] = statsQuery.Result.DailyActiveAdmins - m["stats.daily_active_editors.count"] = statsQuery.Result.DailyActiveEditors - m["stats.daily_active_viewers.count"] = statsQuery.Result.DailyActiveViewers - m["stats.daily_active_sessions.count"] = statsQuery.Result.DailyActiveSessions - m["stats.datasources.count"] = statsQuery.Result.Datasources - m["stats.stars.count"] = statsQuery.Result.Stars - m["stats.folders.count"] = statsQuery.Result.Folders - m["stats.dashboard_permissions.count"] = statsQuery.Result.DashboardPermissions - m["stats.folder_permissions.count"] = statsQuery.Result.FolderPermissions - m["stats.provisioned_dashboards.count"] = statsQuery.Result.ProvisionedDashboards - m["stats.snapshots.count"] = statsQuery.Result.Snapshots - m["stats.teams.count"] = statsQuery.Result.Teams - m["stats.total_auth_token.count"] = statsQuery.Result.AuthTokens - m["stats.dashboard_versions.count"] = statsQuery.Result.DashboardVersions - m["stats.annotations.count"] = statsQuery.Result.Annotations - m["stats.alert_rules.count"] = statsQuery.Result.AlertRules - m["stats.library_panels.count"] = statsQuery.Result.LibraryPanels - m["stats.library_variables.count"] = statsQuery.Result.LibraryVariables - m["stats.dashboards_viewers_can_edit.count"] = statsQuery.Result.DashboardsViewersCanEdit - m["stats.dashboards_viewers_can_admin.count"] = statsQuery.Result.DashboardsViewersCanAdmin - m["stats.folders_viewers_can_edit.count"] = statsQuery.Result.FoldersViewersCanEdit - m["stats.folders_viewers_can_admin.count"] = statsQuery.Result.FoldersViewersCanAdmin - m["stats.api_keys.count"] = statsQuery.Result.APIKeys - m["stats.data_keys.count"] = statsQuery.Result.DataKeys - m["stats.active_data_keys.count"] = statsQuery.Result.ActiveDataKeys - m["stats.public_dashboards.count"] = statsQuery.Result.PublicDashboards + m["stats.alerts.count"] = statsResult.Alerts + m["stats.active_users.count"] = statsResult.ActiveUsers + m["stats.active_admins.count"] = statsResult.ActiveAdmins + m["stats.active_editors.count"] = statsResult.ActiveEditors + m["stats.active_viewers.count"] = statsResult.ActiveViewers + m["stats.active_sessions.count"] = statsResult.ActiveSessions + m["stats.monthly_active_users.count"] = statsResult.MonthlyActiveUsers + m["stats.daily_active_users.count"] = statsResult.DailyActiveUsers + m["stats.daily_active_admins.count"] = statsResult.DailyActiveAdmins + m["stats.daily_active_editors.count"] = statsResult.DailyActiveEditors + m["stats.daily_active_viewers.count"] = statsResult.DailyActiveViewers + m["stats.daily_active_sessions.count"] = statsResult.DailyActiveSessions + m["stats.datasources.count"] = statsResult.Datasources + m["stats.stars.count"] = statsResult.Stars + m["stats.folders.count"] = statsResult.Folders + m["stats.dashboard_permissions.count"] = statsResult.DashboardPermissions + m["stats.folder_permissions.count"] = statsResult.FolderPermissions + m["stats.provisioned_dashboards.count"] = statsResult.ProvisionedDashboards + m["stats.snapshots.count"] = statsResult.Snapshots + m["stats.teams.count"] = statsResult.Teams + m["stats.total_auth_token.count"] = statsResult.AuthTokens + m["stats.dashboard_versions.count"] = statsResult.DashboardVersions + m["stats.annotations.count"] = statsResult.Annotations + m["stats.alert_rules.count"] = statsResult.AlertRules + m["stats.library_panels.count"] = statsResult.LibraryPanels + m["stats.library_variables.count"] = statsResult.LibraryVariables + m["stats.dashboards_viewers_can_edit.count"] = statsResult.DashboardsViewersCanEdit + m["stats.dashboards_viewers_can_admin.count"] = statsResult.DashboardsViewersCanAdmin + m["stats.folders_viewers_can_edit.count"] = statsResult.FoldersViewersCanEdit + m["stats.folders_viewers_can_admin.count"] = statsResult.FoldersViewersCanAdmin + m["stats.api_keys.count"] = statsResult.APIKeys + m["stats.data_keys.count"] = statsResult.DataKeys + m["stats.active_data_keys.count"] = statsResult.ActiveDataKeys + 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 - avgAuthTokensPerUser := statsQuery.Result.AuthTokens + userCount := statsResult.Users + 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{} - if err := s.statsService.GetAlertNotifiersUsageStats(ctx, &anStats); err != nil { + anResult, err := s.statsService.GetAlertNotifiersUsageStats(ctx, &stats.GetAlertNotifierUsageStatsQuery{}) + 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{} - if err := s.statsService.GetDataSourceStats(ctx, &dsStats); err != nil { + dsResult, err := s.statsService.GetDataSourceStats(ctx, &stats.GetDataSourceStatsQuery{}) + 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{} - if err := s.statsService.GetDataSourceAccessStats(ctx, &dsAccessStats); err != nil { + dsAccessResult, err := s.statsService.GetDataSourceAccessStats(ctx, &stats.GetDataSourceAccessStatsQuery{}) + 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{} - if err := s.statsService.GetSystemStats(ctx, &statsQuery); err != nil { + statsResult, err := s.statsService.GetSystemStats(ctx, &stats.GetSystemStatsQuery{}) + 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.MStatTotalFolders.Set(float64(statsQuery.Result.Folders)) - metrics.MStatTotalUsers.Set(float64(statsQuery.Result.Users)) - metrics.MStatTotalTeams.Set(float64(statsQuery.Result.Teams)) - metrics.MStatActiveUsers.Set(float64(statsQuery.Result.ActiveUsers)) - metrics.MStatTotalPlaylists.Set(float64(statsQuery.Result.Playlists)) - metrics.MStatTotalOrgs.Set(float64(statsQuery.Result.Orgs)) - metrics.StatsTotalViewers.Set(float64(statsQuery.Result.Viewers)) - metrics.StatsTotalActiveViewers.Set(float64(statsQuery.Result.ActiveViewers)) - metrics.StatsTotalEditors.Set(float64(statsQuery.Result.Editors)) - metrics.StatsTotalActiveEditors.Set(float64(statsQuery.Result.ActiveEditors)) - metrics.StatsTotalAdmins.Set(float64(statsQuery.Result.Admins)) - metrics.StatsTotalActiveAdmins.Set(float64(statsQuery.Result.ActiveAdmins)) - metrics.StatsTotalDashboardVersions.Set(float64(statsQuery.Result.DashboardVersions)) - metrics.StatsTotalAnnotations.Set(float64(statsQuery.Result.Annotations)) - metrics.StatsTotalAlertRules.Set(float64(statsQuery.Result.AlertRules)) - metrics.StatsTotalLibraryPanels.Set(float64(statsQuery.Result.LibraryPanels)) - metrics.StatsTotalLibraryVariables.Set(float64(statsQuery.Result.LibraryVariables)) + metrics.MStatTotalDashboards.Set(float64(statsResult.Dashboards)) + metrics.MStatTotalFolders.Set(float64(statsResult.Folders)) + metrics.MStatTotalUsers.Set(float64(statsResult.Users)) + metrics.MStatTotalTeams.Set(float64(statsResult.Teams)) + metrics.MStatActiveUsers.Set(float64(statsResult.ActiveUsers)) + metrics.MStatTotalPlaylists.Set(float64(statsResult.Playlists)) + metrics.MStatTotalOrgs.Set(float64(statsResult.Orgs)) + metrics.StatsTotalViewers.Set(float64(statsResult.Viewers)) + metrics.StatsTotalActiveViewers.Set(float64(statsResult.ActiveViewers)) + metrics.StatsTotalEditors.Set(float64(statsResult.Editors)) + metrics.StatsTotalActiveEditors.Set(float64(statsResult.ActiveEditors)) + metrics.StatsTotalAdmins.Set(float64(statsResult.Admins)) + metrics.StatsTotalActiveAdmins.Set(float64(statsResult.ActiveAdmins)) + metrics.StatsTotalDashboardVersions.Set(float64(statsResult.DashboardVersions)) + metrics.StatsTotalAnnotations.Set(float64(statsResult.Annotations)) + metrics.StatsTotalAlertRules.Set(float64(statsResult.AlertRules)) + metrics.StatsTotalLibraryPanels.Set(float64(statsResult.LibraryPanels)) + metrics.StatsTotalLibraryVariables.Set(float64(statsResult.LibraryVariables)) - metrics.StatsTotalDataKeys.With(prometheus.Labels{"active": "true"}).Set(float64(statsQuery.Result.ActiveDataKeys)) - inactiveDataKeys := statsQuery.Result.DataKeys - statsQuery.Result.ActiveDataKeys + metrics.StatsTotalDataKeys.With(prometheus.Labels{"active": "true"}).Set(float64(statsResult.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{} - if err := s.statsService.GetDataSourceStats(ctx, &dsStats); err != nil { + dsResult, err := s.statsService.GetDataSourceStats(ctx, &stats.GetDataSourceStatsQuery{}) + 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 diff --git a/pkg/services/stats/models.go b/pkg/services/stats/models.go index 303037108ea..66ab9dce1ad 100644 --- a/pkg/services/stats/models.go +++ b/pkg/services/stats/models.go @@ -49,13 +49,9 @@ type DataSourceStats struct { Type string } -type GetSystemStatsQuery struct { - Result *SystemStats -} +type GetSystemStatsQuery struct{} -type GetDataSourceStatsQuery struct { - Result []*DataSourceStats -} +type GetDataSourceStatsQuery struct{} type DataSourceAccessStats struct { Type string @@ -63,18 +59,14 @@ type DataSourceAccessStats struct { Count int64 } -type GetDataSourceAccessStatsQuery struct { - Result []*DataSourceAccessStats -} +type GetDataSourceAccessStatsQuery struct{} type NotifierUsageStats struct { Type string Count int64 } -type GetAlertNotifierUsageStatsQuery struct { - Result []*NotifierUsageStats -} +type GetAlertNotifierUsageStatsQuery struct{} type AdminStats struct { Orgs int64 `json:"orgs"` @@ -102,17 +94,13 @@ type AdminStats struct { MonthlyActiveUsers int64 `json:"monthlyActiveUsers"` } -type GetAdminStatsQuery struct { - Result *AdminStats -} +type GetAdminStatsQuery struct{} type SystemUserCountStats struct { Count int64 } -type GetSystemUserCountStatsQuery struct { - Result *SystemUserCountStats -} +type GetSystemUserCountStatsQuery struct{} type UserStats struct { Users int64 diff --git a/pkg/services/stats/stats.go b/pkg/services/stats/stats.go index 986ee5a08d3..7998aff0180 100644 --- a/pkg/services/stats/stats.go +++ b/pkg/services/stats/stats.go @@ -5,10 +5,10 @@ import ( ) type Service interface { - GetAdminStats(ctx context.Context, query *GetAdminStatsQuery) error - GetAlertNotifiersUsageStats(ctx context.Context, query *GetAlertNotifierUsageStatsQuery) error - GetDataSourceStats(ctx context.Context, query *GetDataSourceStatsQuery) error - GetDataSourceAccessStats(ctx context.Context, query *GetDataSourceAccessStatsQuery) error - GetSystemStats(ctx context.Context, query *GetSystemStatsQuery) error - GetSystemUserCountStats(ctx context.Context, query *GetSystemUserCountStatsQuery) error + GetAdminStats(ctx context.Context, query *GetAdminStatsQuery) (*AdminStats, error) + GetAlertNotifiersUsageStats(ctx context.Context, query *GetAlertNotifierUsageStatsQuery) ([]*NotifierUsageStats, error) + GetDataSourceStats(ctx context.Context, query *GetDataSourceStatsQuery) ([]*DataSourceStats, error) + GetDataSourceAccessStats(ctx context.Context, query *GetDataSourceAccessStatsQuery) ([]*DataSourceAccessStats, error) + GetSystemStats(ctx context.Context, query *GetSystemStatsQuery) (*SystemStats, error) + GetSystemUserCountStats(ctx context.Context, query *GetSystemUserCountStatsQuery) (*SystemUserCountStats, error) } diff --git a/pkg/services/stats/statsimpl/stats.go b/pkg/services/stats/statsimpl/stats.go index 030c0878cbe..dfc8875cd6b 100644 --- a/pkg/services/stats/statsimpl/stats.go +++ b/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 { - return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error { +func (ss *sqlStatsService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) (result []*stats.NotifierUsageStats, err 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) - err := dbSession.SQL(rawSQL).Find(&query.Result) + result = make([]*stats.NotifierUsageStats, 0) + err := dbSession.SQL(rawSQL).Find(&result) return err }) + return result, err } -func (ss *sqlStatsService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) error { - return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error { +func (ss *sqlStatsService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) (result []*stats.DataSourceStats, err 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) - err := dbSession.SQL(rawSQL).Find(&query.Result) + result = make([]*stats.DataSourceStats, 0) + err := dbSession.SQL(rawSQL).Find(&result) return err }) + return result, err } -func (ss *sqlStatsService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) error { - return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error { +func (ss *sqlStatsService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) (result []*stats.DataSourceAccessStats, err 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) - err := dbSession.SQL(rawSQL).Find(&query.Result) + result = make([]*stats.DataSourceAccessStats, 0) + 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 { - return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error { +func (ss *sqlStatsService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) (result *stats.SystemStats, err 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 { - return ss.db.WithDbSession(ctx, func(dbSession *db.Session) error { +func (ss *sqlStatsService) GetAdminStats(ctx context.Context, query *stats.GetAdminStatsQuery) (result *stats.AdminStats, err 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 { - return ss.db.WithDbSession(ctx, func(sess *db.Session) error { +func (ss *sqlStatsService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) (result *stats.SystemUserCountStats, err 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 { diff --git a/pkg/services/stats/statsimpl/stats_test.go b/pkg/services/stats/statsimpl/stats_test.go index 678c1870d20..e458f49105c 100644 --- a/pkg/services/stats/statsimpl/stats_test.go +++ b/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(0), query.Result.Editors) - assert.Equal(t, int64(0), query.Result.Viewers) - assert.Equal(t, int64(3), query.Result.Admins) - assert.Equal(t, int64(0), query.Result.LibraryPanels) - assert.Equal(t, int64(0), query.Result.LibraryVariables) - assert.Equal(t, int64(0), query.Result.APIKeys) + assert.Equal(t, int64(3), result.Users) + assert.Equal(t, int64(0), result.Editors) + assert.Equal(t, int64(0), result.Viewers) + assert.Equal(t, int64(3), result.Admins) + assert.Equal(t, int64(0), result.LibraryPanels) + assert.Equal(t, int64(0), result.LibraryVariables) + 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) } diff --git a/pkg/services/stats/statstest/stats.go b/pkg/services/stats/statstest/stats.go index c137aee4044..679a5d68788 100644 --- a/pkg/services/stats/statstest/stats.go +++ b/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 { - return s.ExpectedError +func (s *FakeService) GetAdminStats(ctx context.Context, query *stats.GetAdminStatsQuery) (*stats.AdminStats, error) { + return nil, s.ExpectedError } -func (s *FakeService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) error { - query.Result = s.ExpectedNotifierUsageStats - return s.ExpectedError +func (s *FakeService) GetAlertNotifiersUsageStats(ctx context.Context, query *stats.GetAlertNotifierUsageStatsQuery) ([]*stats.NotifierUsageStats, error) { + return s.ExpectedNotifierUsageStats, s.ExpectedError } -func (s *FakeService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) error { - query.Result = s.ExpectedDataSourceStats - return s.ExpectedError +func (s *FakeService) GetDataSourceStats(ctx context.Context, query *stats.GetDataSourceStatsQuery) ([]*stats.DataSourceStats, error) { + return s.ExpectedDataSourceStats, s.ExpectedError } -func (s *FakeService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) error { - query.Result = s.ExpectedDataSourcesAccessStats - return s.ExpectedError +func (s *FakeService) GetDataSourceAccessStats(ctx context.Context, query *stats.GetDataSourceAccessStatsQuery) ([]*stats.DataSourceAccessStats, error) { + return s.ExpectedDataSourcesAccessStats, s.ExpectedError } -func (s *FakeService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) error { - query.Result = s.ExpectedSystemStats - return s.ExpectedError +func (s *FakeService) GetSystemStats(ctx context.Context, query *stats.GetSystemStatsQuery) (*stats.SystemStats, error) { + return s.ExpectedSystemStats, s.ExpectedError } -func (s *FakeService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) error { - return s.ExpectedError +func (s *FakeService) GetSystemUserCountStats(ctx context.Context, query *stats.GetSystemUserCountStatsQuery) (*stats.SystemUserCountStats, error) { + return nil, s.ExpectedError }