snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/app/analytics.go

@@ -0,0 +1,350 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package app
+
+import (
+	"net/http"
+
+	"golang.org/x/sync/errgroup"
+
+	"github.com/mattermost/mattermost/server/public/model"
+	"github.com/mattermost/mattermost/server/public/shared/mlog"
+	"github.com/mattermost/mattermost/server/public/shared/request"
+)
+
+const (
+	DayMilliseconds   = 24 * 60 * 60 * 1000
+	MonthMilliseconds = 31 * DayMilliseconds
+)
+
+func (a *App) GetAnalytics(rctx request.CTX, name string, teamID string) (model.AnalyticsRows, *model.AppError) {
+	return a.getAnalytics(rctx, name, teamID, false)
+}
+
+func (a *App) GetAnalyticsForSupportPacket(rctx request.CTX) (model.AnalyticsRows, *model.AppError) {
+	return a.getAnalytics(rctx, "standard", "", true)
+}
+
+func (a *App) getAnalytics(rctx request.CTX, name string, teamID string, forSupportPacket bool) (model.AnalyticsRows, *model.AppError) {
+	systemUserCount, err := a.Srv().Store().User().Count(model.UserCountOptions{})
+	if err != nil {
+		return nil, model.NewAppError("GetAnalytics", "app.user.get_total_users_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+	}
+
+	skipIntensiveQueries := false
+	// When generating a Support Packet, always run intensive queries.
+	if !forSupportPacket && systemUserCount > int64(*a.Config().AnalyticsSettings.MaxUsersForStatistics) {
+		rctx.Logger().Warn("Number of users in the system is higher than the configured limit. Skipping intensive SQL queries.", mlog.Int("limit", *a.Config().AnalyticsSettings.MaxUsersForStatistics))
+		skipIntensiveQueries = true
+	}
+
+	switch name {
+	case "standard":
+		return a.getStandardAnalytics(rctx, teamID, systemUserCount)
+	case "bot_post_counts_day":
+		return a.getBotPostCountsAnalytics(rctx, teamID)
+	case "post_counts_day":
+		return a.getPostCountsAnalytics(rctx, teamID)
+	case "user_counts_with_posts_day":
+		return a.getUserCountsWithPostsAnalytics(rctx, teamID, skipIntensiveQueries)
+	case "extra_counts":
+		return a.getExtraCountsAnalytics(rctx, teamID)
+	default:
+		return nil, nil
+	}
+}
+
+func (a *App) getStandardAnalytics(rctx request.CTX, teamID string, systemUserCount int64) (model.AnalyticsRows, *model.AppError) {
+	var rows model.AnalyticsRows = make([]*model.AnalyticsRow, 12)
+	rows[0] = &model.AnalyticsRow{Name: "channel_open_count", Value: 0}
+	rows[1] = &model.AnalyticsRow{Name: "channel_private_count", Value: 0}
+	rows[2] = &model.AnalyticsRow{Name: "post_count", Value: 0}
+	rows[3] = &model.AnalyticsRow{Name: "unique_user_count", Value: 0}
+	rows[4] = &model.AnalyticsRow{Name: "team_count", Value: 0}
+	rows[5] = &model.AnalyticsRow{Name: "total_websocket_connections", Value: 0}
+	rows[6] = &model.AnalyticsRow{Name: "total_master_db_connections", Value: 0}
+	rows[7] = &model.AnalyticsRow{Name: "total_read_db_connections", Value: 0}
+	rows[8] = &model.AnalyticsRow{Name: "daily_active_users", Value: 0}
+	rows[9] = &model.AnalyticsRow{Name: "monthly_active_users", Value: 0}
+	rows[10] = &model.AnalyticsRow{Name: "inactive_user_count", Value: 0}
+	rows[11] = &model.AnalyticsRow{Name: "single_channel_guest_count", Value: 0}
+
+	var g errgroup.Group
+	g.SetLimit(2)
+	var channelCounts map[model.ChannelType]int64
+	g.Go(func() error {
+		var err error
+		if channelCounts, err = a.Srv().Store().Channel().AnalyticsCountAll(teamID); err != nil {
+			return model.NewAppError("GetAnalytics", "app.channel.analytics_type_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var usersCount int64
+	var inactiveUsersCount int64
+	if teamID == "" {
+		g.Go(func() error {
+			var err error
+			if inactiveUsersCount, err = a.Srv().Store().User().AnalyticsGetInactiveUsersCount(); err != nil {
+				return model.NewAppError("GetAnalytics", "app.user.analytics_get_inactive_users_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+			}
+			return nil
+		})
+	} else {
+		g.Go(func() error {
+			var err error
+			if usersCount, err = a.Srv().Store().User().Count(model.UserCountOptions{TeamId: teamID}); err != nil {
+				return model.NewAppError("GetAnalytics", "app.user.get_total_users_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+			}
+			return nil
+		})
+	}
+
+	var postsCount int64
+	g.Go(func() error {
+		var err error
+		if postsCount, err = a.Srv().Store().Post().AnalyticsPostCountByTeam(teamID); err != nil {
+			return model.NewAppError("GetAnalytics", "app.post.analytics_posts_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var teamsCount int64
+	g.Go(func() error {
+		var err error
+		if teamsCount, err = a.Srv().Store().Team().AnalyticsTeamCount(nil); err != nil {
+			return model.NewAppError("GetAnalytics", "app.team.analytics_team_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var dailyActiveUsersCount int64
+	g.Go(func() error {
+		var err error
+		if dailyActiveUsersCount, err = a.Srv().Store().User().AnalyticsActiveCount(DayMilliseconds, model.UserCountOptions{IncludeBotAccounts: false, IncludeDeleted: false}); err != nil {
+			return model.NewAppError("GetAnalytics", "app.user.analytics_daily_active_users.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var monthlyActiveUsersCount int64
+	g.Go(func() error {
+		var err error
+		if monthlyActiveUsersCount, err = a.Srv().Store().User().AnalyticsActiveCount(MonthMilliseconds, model.UserCountOptions{IncludeBotAccounts: false, IncludeDeleted: false}); err != nil {
+			return model.NewAppError("GetAnalytics", "app.user.analytics_daily_active_users.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var singleChannelGuestCount int64
+	if a.shouldTrackSingleChannelGuests() {
+		g.Go(func() error {
+			var err error
+			if singleChannelGuestCount, err = a.Srv().Store().User().AnalyticsGetSingleChannelGuestCount(); err != nil {
+				return model.NewAppError("GetAnalytics", "app.user.analytics_get_single_channel_guest_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+			}
+			return nil
+		})
+	}
+
+	if err := g.Wait(); err != nil {
+		return nil, err.(*model.AppError)
+	}
+
+	rows[0].Value = float64(channelCounts[model.ChannelTypeOpen])
+	rows[1].Value = float64(channelCounts[model.ChannelTypePrivate])
+	rows[2].Value = float64(postsCount)
+
+	if teamID == "" {
+		rows[3].Value = float64(systemUserCount)
+		rows[10].Value = float64(inactiveUsersCount)
+	} else {
+		rows[3].Value = float64(usersCount)
+		rows[10].Value = -1
+	}
+
+	rows[4].Value = float64(teamsCount)
+
+	// If in HA mode then aggregate all the stats
+	if a.Cluster() != nil && *a.Config().ClusterSettings.Enable {
+		stats, err2 := a.Cluster().GetClusterStats(rctx)
+		if err2 != nil {
+			return nil, err2
+		}
+
+		totalSockets := a.TotalWebsocketConnections()
+		totalMasterDb := a.Srv().Store().TotalMasterDbConnections()
+		totalReadDb := a.Srv().Store().TotalReadDbConnections()
+
+		for _, stat := range stats {
+			totalSockets = totalSockets + stat.TotalWebsocketConnections
+			totalMasterDb = totalMasterDb + stat.TotalMasterDbConnections
+			totalReadDb = totalReadDb + stat.TotalReadDbConnections
+		}
+
+		rows[5].Value = float64(totalSockets)
+		rows[6].Value = float64(totalMasterDb)
+		rows[7].Value = float64(totalReadDb)
+	} else {
+		rows[5].Value = float64(a.TotalWebsocketConnections())
+		rows[6].Value = float64(a.Srv().Store().TotalMasterDbConnections())
+		rows[7].Value = float64(a.Srv().Store().TotalReadDbConnections())
+	}
+
+	rows[8].Value = float64(dailyActiveUsersCount)
+	rows[9].Value = float64(monthlyActiveUsersCount)
+	rows[11].Value = float64(singleChannelGuestCount)
+
+	return rows, nil
+}
+
+func (a *App) getBotPostCountsAnalytics(rctx request.CTX, teamID string) (model.AnalyticsRows, *model.AppError) {
+	analyticsRows, nErr := a.Srv().Store().Post().AnalyticsPostCountsByDay(&model.AnalyticsPostCountsOptions{
+		TeamId:   teamID,
+		BotsOnly: true,
+	})
+	if nErr != nil {
+		return nil, model.NewAppError("GetAnalytics", "app.post.analytics_posts_count_by_day.app_error", nil, "", http.StatusInternalServerError).Wrap(nErr)
+	}
+
+	return analyticsRows, nil
+}
+
+func (a *App) getPostCountsAnalytics(rctx request.CTX, teamID string) (model.AnalyticsRows, *model.AppError) {
+	analyticsRows, nErr := a.Srv().Store().Post().AnalyticsPostCountsByDay(&model.AnalyticsPostCountsOptions{
+		TeamId:   teamID,
+		BotsOnly: false,
+	})
+	if nErr != nil {
+		return nil, model.NewAppError("GetAnalytics", "app.post.analytics_posts_count_by_day.app_error", nil, "", http.StatusInternalServerError).Wrap(nErr)
+	}
+
+	return analyticsRows, nil
+}
+
+func (a *App) getUserCountsWithPostsAnalytics(rctx request.CTX, teamID string, skipIntensiveQueries bool) (model.AnalyticsRows, *model.AppError) {
+	if skipIntensiveQueries {
+		rows := model.AnalyticsRows{&model.AnalyticsRow{Name: "", Value: -1}}
+		return rows, nil
+	}
+
+	analyticsRows, nErr := a.Srv().Store().Post().AnalyticsUserCountsWithPostsByDay(teamID)
+	if nErr != nil {
+		return nil, model.NewAppError("GetAnalytics", "app.post.analytics_user_counts_posts_by_day.app_error", nil, "", http.StatusInternalServerError).Wrap(nErr)
+	}
+
+	return analyticsRows, nil
+}
+
+func (a *App) getExtraCountsAnalytics(rctx request.CTX, teamID string) (model.AnalyticsRows, *model.AppError) {
+	var rows model.AnalyticsRows = make([]*model.AnalyticsRow, 6)
+	rows[0] = &model.AnalyticsRow{Name: "incoming_webhook_count", Value: 0}
+	rows[1] = &model.AnalyticsRow{Name: "outgoing_webhook_count", Value: 0}
+	rows[2] = &model.AnalyticsRow{Name: "command_count", Value: 0}
+	rows[3] = &model.AnalyticsRow{Name: "session_count", Value: 0}
+	rows[4] = &model.AnalyticsRow{Name: "total_file_count", Value: 0}
+	rows[5] = &model.AnalyticsRow{Name: "total_file_size", Value: 0}
+
+	var incomingWebhookCount int64
+	var g errgroup.Group
+	g.SetLimit(2)
+	g.Go(func() error {
+		var err error
+		if incomingWebhookCount, err = a.Srv().Store().Webhook().AnalyticsIncomingCount(teamID, ""); err != nil {
+			return model.NewAppError("GetAnalytics", "app.webhooks.analytics_incoming_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var outgoingWebhookCount int64
+	g.Go(func() error {
+		var err error
+		if outgoingWebhookCount, err = a.Srv().Store().Webhook().AnalyticsOutgoingCount(teamID); err != nil {
+			return model.NewAppError("GetAnalytics", "app.webhooks.analytics_outgoing_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var commandsCount int64
+	g.Go(func() error {
+		var err error
+		if commandsCount, err = a.Srv().Store().Command().AnalyticsCommandCount(teamID); err != nil {
+			return model.NewAppError("GetAnalytics", "app.analytics.getanalytics.internal_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var sessionsCount int64
+	g.Go(func() error {
+		var err error
+		if sessionsCount, err = a.Srv().Store().Session().AnalyticsSessionCount(); err != nil {
+			return model.NewAppError("GetAnalytics", "app.session.analytics_session_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var fileCount int64
+	g.Go(func() error {
+		var err error
+		if fileCount, err = a.Srv().Store().FileInfo().CountAll(); err != nil {
+			return model.NewAppError("GetAnalytics", "app.file_info.get_count.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	var fileSize int64
+	g.Go(func() error {
+		var err error
+		if fileSize, err = a.Srv().Store().FileInfo().GetStorageUsage(false, false); err != nil {
+			return model.NewAppError("GetAnalytics", "app.file_info.get_storage_usage.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+		}
+		return nil
+	})
+
+	if err := g.Wait(); err != nil {
+		return nil, err.(*model.AppError)
+	}
+
+	rows[0].Value = float64(incomingWebhookCount)
+	rows[1].Value = float64(outgoingWebhookCount)
+	rows[2].Value = float64(commandsCount)
+	rows[3].Value = float64(sessionsCount)
+	rows[4].Value = float64(fileCount)
+	rows[5].Value = float64(fileSize)
+
+	return rows, nil
+}
+
+func (a *App) GetRecentlyActiveUsersForTeam(rctx request.CTX, teamID string) (map[string]*model.User, *model.AppError) {
+	users, err := a.Srv().Store().User().GetRecentlyActiveUsersForTeam(teamID, 0, 100, nil)
+	if err != nil {
+		return nil, model.NewAppError("GetRecentlyActiveUsersForTeam", "app.user.get_recently_active_users.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+	}
+
+	userMap := make(map[string]*model.User)
+
+	for _, user := range users {
+		userMap[user.Id] = user
+	}
+
+	return userMap, nil
+}
+
+func (a *App) GetRecentlyActiveUsersForTeamPage(rctx request.CTX, teamID string, page, perPage int, asAdmin bool, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, *model.AppError) {
+	users, err := a.Srv().Store().User().GetRecentlyActiveUsersForTeam(teamID, page*perPage, perPage, viewRestrictions)
+	if err != nil {
+		return nil, model.NewAppError("GetRecentlyActiveUsersForTeamPage", "app.user.get_recently_active_users.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+	}
+
+	return a.sanitizeProfiles(users, asAdmin), nil
+}
+
+func (a *App) GetNewUsersForTeamPage(rctx request.CTX, teamID string, page, perPage int, asAdmin bool, viewRestrictions *model.ViewUsersRestrictions) ([]*model.User, *model.AppError) {
+	users, err := a.Srv().Store().User().GetNewUsersForTeam(teamID, page*perPage, perPage, viewRestrictions)
+	if err != nil {
+		return nil, model.NewAppError("GetNewUsersForTeamPage", "app.user.get_new_users.app_error", nil, "", http.StatusInternalServerError).Wrap(err)
+	}
+
+	return a.sanitizeProfiles(users, asAdmin), nil
+}