apitech
/
grafana
mirror of https://github.com/grafana/grafana
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Chore: Remove result field from stats (#65166)

Browse Source 
remove result field from stats
pull/65589/head
Serge Zaitsev 3 years ago committed by GitHub
parent 4b551ae532
commit 2025c1dac1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 150 additions and 161 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 7
      pkg/api/admin.go
  2. 164
      pkg/infra/usagestats/statscollector/service.go
  3. 24
      pkg/services/stats/models.go
  4. 12
      pkg/services/stats/stats.go
  5. 48
      pkg/services/stats/statsimpl/stats.go
  6. 28
      pkg/services/stats/statsimpl/stats_test.go
  7. 28
      pkg/services/stats/statstest/stats.go

7
pkg/api/admin.go
Unescape View File

@ -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) {

164
pkg/infra/usagestats/statscollector/service.go
Unescape View File

@ -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.StatsTotalDataKeys.With(prometheus.Labels{"active": "true"}).Set(float64(statsQuery.Result.ActiveDataKeys))
inactiveDataKeys := statsQuery.Result.DataKeys - statsQuery.Result.ActiveDataKeys
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(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

24
pkg/services/stats/models.go
Unescape View File

@ -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

12
pkg/services/stats/stats.go
Unescape View File

@ -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)
}

48
pkg/services/stats/statsimpl/stats.go
Unescape View File

@ -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 {

28
pkg/services/stats/statsimpl/stats_test.go
Unescape View File

@ -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)
}

28
pkg/services/stats/statstest/stats.go
Unescape View File

@ -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
}

Write Preview
Loading…
Cancel
Save