MM-60487: Consolidate config telemetry (#28200)

server/platform/services/telemetry/telemetry.go

@@ -91,6 +91,7 @@ const (
 	TrackLicense  = "license"
 	TrackServer   = "server"
 	TrackPlugins  = "plugins"
+	TrackConfigs  = "configs"
 )
 
 type TrackSKU string
@@ -471,7 +472,9 @@ func (ts *TelemetryService) trackActivity() {
 
 func (ts *TelemetryService) trackConfig() {
 	cfg := ts.srv.Config()
-	ts.SendTelemetry(TrackConfigService, map[string]any{
+	configs := map[string]any{}
+
+	configs[TrackConfigService] = map[string]any{
 		"web_server_mode":                                         *cfg.ServiceSettings.WebserverMode,
 		"enable_security_fix_alert":                               *cfg.ServiceSettings.EnableSecurityFixAlert,
 		"enable_insecure_outgoing_connections":                    *cfg.ServiceSettings.EnableInsecureOutgoingConnections,
@@ -565,9 +568,9 @@ func (ts *TelemetryService) trackConfig() {
 		"refresh_post_stats_run_time":                             *cfg.ServiceSettings.RefreshPostStatsRunTime,
 		"maximum_payload_size":                                    *cfg.ServiceSettings.MaximumPayloadSizeBytes,
 		"maximum_url_length":                                      *cfg.ServiceSettings.MaximumURLLength,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigTeam, map[string]any{
+	configs[TrackConfigTeam] = map[string]any{
 		"enable_user_creation":                    cfg.TeamSettings.EnableUserCreation,
 		"enable_open_server":                      *cfg.TeamSettings.EnableOpenServer,
 		"enable_user_deactivation":                *cfg.TeamSettings.EnableUserDeactivation,
@@ -589,16 +592,16 @@ func (ts *TelemetryService) trackConfig() {
 		"experimental_enable_automatic_replies":   *cfg.TeamSettings.ExperimentalEnableAutomaticReplies,
 		"experimental_primary_team":               isDefault(*cfg.TeamSettings.ExperimentalPrimaryTeam, ""),
 		"experimental_default_channels":           len(cfg.TeamSettings.ExperimentalDefaultChannels),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigClientReq, map[string]any{
+	configs[TrackConfigClientReq] = map[string]any{
 		"android_latest_version": cfg.ClientRequirements.AndroidLatestVersion,
 		"android_min_version":    cfg.ClientRequirements.AndroidMinVersion,
 		"ios_latest_version":     cfg.ClientRequirements.IosLatestVersion,
 		"ios_min_version":        cfg.ClientRequirements.IosMinVersion,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigSQL, map[string]any{
+	configs[TrackConfigSQL] = map[string]any{
 		"driver_name":                          *cfg.SqlSettings.DriverName,
 		"trace":                                cfg.SqlSettings.Trace,
 		"max_idle_conns":                       *cfg.SqlSettings.MaxIdleConns,
@@ -611,9 +614,9 @@ func (ts *TelemetryService) trackConfig() {
 		"disable_database_search":              *cfg.SqlSettings.DisableDatabaseSearch,
 		"migrations_statement_timeout_seconds": *cfg.SqlSettings.MigrationsStatementTimeoutSeconds,
 		"replica_monitor_interval_seconds":     *cfg.SqlSettings.ReplicaMonitorIntervalSeconds,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigLog, map[string]any{
+	configs[TrackConfigLog] = map[string]any{
 		"enable_console":           cfg.LogSettings.EnableConsole,
 		"console_level":            cfg.LogSettings.ConsoleLevel,
 		"console_json":             *cfg.LogSettings.ConsoleJson,
@@ -623,9 +626,9 @@ func (ts *TelemetryService) trackConfig() {
 		"enable_webhook_debugging": cfg.LogSettings.EnableWebhookDebugging,
 		"isdefault_file_location":  isDefault(cfg.LogSettings.FileLocation, ""),
 		"advanced_logging_json":    len(cfg.LogSettings.AdvancedLoggingJSON) != 0,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigAudit, map[string]any{
+	configs[TrackConfigAudit] = map[string]any{
 		"file_enabled":          *cfg.ExperimentalAuditSettings.FileEnabled,
 		"file_max_size_mb":      *cfg.ExperimentalAuditSettings.FileMaxSizeMB,
 		"file_max_age_days":     *cfg.ExperimentalAuditSettings.FileMaxAgeDays,
@@ -633,9 +636,9 @@ func (ts *TelemetryService) trackConfig() {
 		"file_compress":         *cfg.ExperimentalAuditSettings.FileCompress,
 		"file_max_queue_size":   *cfg.ExperimentalAuditSettings.FileMaxQueueSize,
 		"advanced_logging_json": len(cfg.ExperimentalAuditSettings.AdvancedLoggingJSON) != 0,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigNotificationLog, map[string]any{
+	configs[TrackConfigNotificationLog] = map[string]any{
 		"enable_console":          *cfg.NotificationLogSettings.EnableConsole,
 		"console_level":           *cfg.NotificationLogSettings.ConsoleLevel,
 		"console_json":            *cfg.NotificationLogSettings.ConsoleJson,
@@ -644,17 +647,17 @@ func (ts *TelemetryService) trackConfig() {
 		"file_json":               *cfg.NotificationLogSettings.FileJson,
 		"isdefault_file_location": isDefault(*cfg.NotificationLogSettings.FileLocation, ""),
 		"advanced_logging_json":   len(cfg.NotificationLogSettings.AdvancedLoggingJSON) != 0,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigPassword, map[string]any{
+	configs[TrackConfigPassword] = map[string]any{
 		"minimum_length": *cfg.PasswordSettings.MinimumLength,
 		"lowercase":      *cfg.PasswordSettings.Lowercase,
 		"number":         *cfg.PasswordSettings.Number,
 		"uppercase":      *cfg.PasswordSettings.Uppercase,
 		"symbol":         *cfg.PasswordSettings.Symbol,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigFile, map[string]any{
+	configs[TrackConfigFile] = map[string]any{
 		"enable_public_links":           cfg.FileSettings.EnablePublicLink,
 		"driver_name":                   *cfg.FileSettings.DriverName,
 		"isdefault_directory":           isDefault(*cfg.FileSettings.Directory, model.FileSettingsDefaultDirectory),
@@ -671,9 +674,9 @@ func (ts *TelemetryService) trackConfig() {
 		"enable_file_attachments":       *cfg.FileSettings.EnableFileAttachments,
 		"enable_mobile_upload":          *cfg.FileSettings.EnableMobileUpload,
 		"enable_mobile_download":        *cfg.FileSettings.EnableMobileDownload,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigEmail, map[string]any{
+	configs[TrackConfigEmail] = map[string]any{
 		"enable_sign_up_with_email":            cfg.EmailSettings.EnableSignUpWithEmail,
 		"enable_sign_in_with_email":            *cfg.EmailSettings.EnableSignInWithEmail,
 		"enable_sign_in_with_username":         *cfg.EmailSettings.EnableSignInWithUsername,
@@ -698,9 +701,9 @@ func (ts *TelemetryService) trackConfig() {
 		"isdefault_login_button_border_color":  isDefault(*cfg.EmailSettings.LoginButtonBorderColor, ""),
 		"isdefault_login_button_text_color":    isDefault(*cfg.EmailSettings.LoginButtonTextColor, ""),
 		"smtp_server_timeout":                  *cfg.EmailSettings.SMTPServerTimeout,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigRate, map[string]any{
+	configs[TrackConfigRate] = map[string]any{
 		"enable_rate_limiter":      *cfg.RateLimitSettings.Enable,
 		"vary_by_remote_address":   *cfg.RateLimitSettings.VaryByRemoteAddr,
 		"vary_by_user":             *cfg.RateLimitSettings.VaryByUser,
@@ -708,21 +711,21 @@ func (ts *TelemetryService) trackConfig() {
 		"max_burst":                *cfg.RateLimitSettings.MaxBurst,
 		"memory_store_size":        *cfg.RateLimitSettings.MemoryStoreSize,
 		"isdefault_vary_by_header": isDefault(cfg.RateLimitSettings.VaryByHeader, ""),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigPrivacy, map[string]any{
+	configs[TrackConfigPrivacy] = map[string]any{
 		"show_email_address": cfg.PrivacySettings.ShowEmailAddress,
 		"show_full_name":     cfg.PrivacySettings.ShowFullName,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigTheme, map[string]any{
+	configs[TrackConfigTheme] = map[string]any{
 		"enable_theme_selection":  *cfg.ThemeSettings.EnableThemeSelection,
 		"isdefault_default_theme": isDefault(*cfg.ThemeSettings.DefaultTheme, model.TeamSettingsDefaultTeamText),
 		"allow_custom_themes":     *cfg.ThemeSettings.AllowCustomThemes,
 		"allowed_themes":          len(cfg.ThemeSettings.AllowedThemes),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigOAuth, map[string]any{
+	configs[TrackConfigOAuth] = map[string]any{
 		"enable_gitlab":    cfg.GitLabSettings.Enable,
 		"openid_gitlab":    *cfg.GitLabSettings.Enable && strings.Contains(*cfg.GitLabSettings.Scope, model.ServiceOpenid),
 		"enable_google":    cfg.GoogleSettings.Enable,
@@ -730,9 +733,9 @@ func (ts *TelemetryService) trackConfig() {
 		"enable_office365": cfg.Office365Settings.Enable,
 		"openid_office365": *cfg.Office365Settings.Enable && strings.Contains(*cfg.Office365Settings.Scope, model.ServiceOpenid),
 		"enable_openid":    cfg.OpenIdSettings.Enable,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigSupport, map[string]any{
+	configs[TrackConfigSupport] = map[string]any{
 		"isdefault_terms_of_service_link":              isDefault(*cfg.SupportSettings.TermsOfServiceLink, model.SupportSettingsDefaultTermsOfServiceLink),
 		"isdefault_privacy_policy_link":                isDefault(*cfg.SupportSettings.PrivacyPolicyLink, model.SupportSettingsDefaultPrivacyPolicyLink),
 		"isdefault_about_link":                         isDefault(*cfg.SupportSettings.AboutLink, model.SupportSettingsDefaultAboutLink),
@@ -742,9 +745,9 @@ func (ts *TelemetryService) trackConfig() {
 		"custom_terms_of_service_enabled":              *cfg.SupportSettings.CustomTermsOfServiceEnabled,
 		"custom_terms_of_service_re_acceptance_period": *cfg.SupportSettings.CustomTermsOfServiceReAcceptancePeriod,
 		"enable_ask_community_link":                    *cfg.SupportSettings.EnableAskCommunityLink,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigLDAP, map[string]any{
+	configs[TrackConfigLDAP] = map[string]any{
 		"enable":                                 *cfg.LdapSettings.Enable,
 		"enable_sync":                            *cfg.LdapSettings.EnableSync,
 		"enable_admin_filter":                    *cfg.LdapSettings.EnableAdminFilter,
@@ -773,20 +776,20 @@ func (ts *TelemetryService) trackConfig() {
 		"isnotempty_picture_attribute":           !isDefault(*cfg.LdapSettings.PictureAttribute, ""),
 		"isnotempty_public_certificate":          !isDefault(*cfg.LdapSettings.PublicCertificateFile, ""),
 		"isnotempty_private_key":                 !isDefault(*cfg.LdapSettings.PrivateKeyFile, ""),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigCompliance, map[string]any{
+	configs[TrackConfigCompliance] = map[string]any{
 		"enable":       *cfg.ComplianceSettings.Enable,
 		"enable_daily": *cfg.ComplianceSettings.EnableDaily,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigLocalization, map[string]any{
+	configs[TrackConfigLocalization] = map[string]any{
 		"default_server_locale": *cfg.LocalizationSettings.DefaultServerLocale,
 		"default_client_locale": *cfg.LocalizationSettings.DefaultClientLocale,
 		"available_locales":     *cfg.LocalizationSettings.AvailableLocales,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigSAML, map[string]any{
+	configs[TrackConfigSAML] = map[string]any{
 		"enable":                              *cfg.SamlSettings.Enable,
 		"enable_sync_with_ldap":               *cfg.SamlSettings.EnableSyncWithLdap,
 		"enable_sync_with_ldap_include_auth":  *cfg.SamlSettings.EnableSyncWithLdapIncludeAuth,
@@ -813,9 +816,9 @@ func (ts *TelemetryService) trackConfig() {
 		"isdefault_login_button_color":        isDefault(*cfg.SamlSettings.LoginButtonColor, ""),
 		"isdefault_login_button_border_color": isDefault(*cfg.SamlSettings.LoginButtonBorderColor, ""),
 		"isdefault_login_button_text_color":   isDefault(*cfg.SamlSettings.LoginButtonTextColor, ""),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigCluster, map[string]any{
+	configs[TrackConfigCluster] = map[string]any{
 		"enable":                                *cfg.ClusterSettings.Enable,
 		"network_interface":                     isDefault(*cfg.ClusterSettings.NetworkInterface, ""),
 		"bind_address":                          isDefault(*cfg.ClusterSettings.BindAddress, ""),
@@ -824,22 +827,22 @@ func (ts *TelemetryService) trackConfig() {
 		"enable_experimental_gossip_encryption": *cfg.ClusterSettings.EnableExperimentalGossipEncryption,
 		"enable_gossip_compression":             *cfg.ClusterSettings.EnableGossipCompression,
 		"read_only_config":                      *cfg.ClusterSettings.ReadOnlyConfig,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigMetrics, map[string]any{
+	configs[TrackConfigMetrics] = map[string]any{
 		"enable":                *cfg.MetricsSettings.Enable,
 		"block_profile_rate":    *cfg.MetricsSettings.BlockProfileRate,
 		"enable_client_metrics": *cfg.MetricsSettings.EnableClientMetrics,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigNativeApp, map[string]any{
+	configs[TrackConfigNativeApp] = map[string]any{
 		"isdefault_app_custom_url_schemes":    isDefaultArray(cfg.NativeAppSettings.AppCustomURLSchemes, model.GetDefaultAppCustomURLSchemes()),
 		"isdefault_app_download_link":         isDefault(*cfg.NativeAppSettings.AppDownloadLink, model.NativeappSettingsDefaultAppDownloadLink),
 		"isdefault_android_app_download_link": isDefault(*cfg.NativeAppSettings.AndroidAppDownloadLink, model.NativeappSettingsDefaultAndroidAppDownloadLink),
 		"isdefault_iosapp_download_link":      isDefault(*cfg.NativeAppSettings.IosAppDownloadLink, model.NativeappSettingsDefaultIosAppDownloadLink),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigExperimental, map[string]any{
+	configs[TrackConfigExperimental] = map[string]any{
 		"client_side_cert_enable":             *cfg.ExperimentalSettings.ClientSideCertEnable,
 		"isdefault_client_side_cert_check":    isDefault(*cfg.ExperimentalSettings.ClientSideCertCheck, model.ClientSideCertCheckPrimaryAuth),
 		"link_metadata_timeout_milliseconds":  *cfg.ExperimentalSettings.LinkMetadataTimeoutMilliseconds,
@@ -848,22 +851,22 @@ func (ts *TelemetryService) trackConfig() {
 		"disable_refetching_on_browser_focus": *cfg.ExperimentalSettings.DisableRefetchingOnBrowserFocus,
 		"delay_channel_autocomplete":          *cfg.ExperimentalSettings.DelayChannelAutocomplete,
 		"youtube_referrer_policy":             *cfg.ExperimentalSettings.YoutubeReferrerPolicy,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigAnalytics, map[string]any{
+	configs[TrackConfigAnalytics] = map[string]any{
 		"isdefault_max_users_for_statistics": isDefault(*cfg.AnalyticsSettings.MaxUsersForStatistics, model.AnalyticsSettingsDefaultMaxUsersForStatistics),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigAnnouncement, map[string]any{
+	configs[TrackConfigAnnouncement] = map[string]any{
 		"enable_banner":               *cfg.AnnouncementSettings.EnableBanner,
 		"isdefault_banner_color":      isDefault(*cfg.AnnouncementSettings.BannerColor, model.AnnouncementSettingsDefaultBannerColor),
 		"isdefault_banner_text_color": isDefault(*cfg.AnnouncementSettings.BannerTextColor, model.AnnouncementSettingsDefaultBannerTextColor),
 		"allow_banner_dismissal":      *cfg.AnnouncementSettings.AllowBannerDismissal,
 		"admin_notices_enabled":       *cfg.AnnouncementSettings.AdminNoticesEnabled,
 		"user_notices_enabled":        *cfg.AnnouncementSettings.UserNoticesEnabled,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigElasticsearch, map[string]any{
+	configs[TrackConfigElasticsearch] = map[string]any{
 		"isdefault_connection_url": isDefault(*cfg.ElasticsearchSettings.ConnectionURL, model.ElasticsearchSettingsDefaultConnectionURL),
 		"isdefault_username":       isDefault(*cfg.ElasticsearchSettings.Username, model.ElasticsearchSettingsDefaultUsername),
 		"isdefault_password":       isDefault(*cfg.ElasticsearchSettings.Password, model.ElasticsearchSettingsDefaultPassword),
@@ -886,11 +889,11 @@ func (ts *TelemetryService) trackConfig() {
 		"isdefault_client_cert":    isDefault(*cfg.ElasticsearchSettings.ClientCert, ""),
 		"isdefault_client_key":     isDefault(*cfg.ElasticsearchSettings.ClientKey, ""),
 		"trace":                    *cfg.ElasticsearchSettings.Trace,
-	})
+	}
 
-	ts.trackPluginConfig(cfg, model.PluginSettingsDefaultMarketplaceURL)
+	ts.trackPluginConfig(configs, cfg, model.PluginSettingsDefaultMarketplaceURL)
 
-	ts.SendTelemetry(TrackConfigDataRetention, map[string]any{
+	configs[TrackConfigDataRetention] = map[string]any{
 		"enable_message_deletion":       *cfg.DataRetentionSettings.EnableMessageDeletion,
 		"enable_file_deletion":          *cfg.DataRetentionSettings.EnableFileDeletion,
 		"message_retention_days":        *cfg.DataRetentionSettings.MessageRetentionDays,
@@ -903,9 +906,9 @@ func (ts *TelemetryService) trackConfig() {
 		"retention_ids_batch_size":      *cfg.DataRetentionSettings.RetentionIdsBatchSize,
 		"cleanup_jobs_threshold_days":   *cfg.JobSettings.CleanupJobsThresholdDays,
 		"cleanup_config_threshold_days": *cfg.JobSettings.CleanupConfigThresholdDays,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigMessageExport, map[string]any{
+	configs[TrackConfigMessageExport] = map[string]any{
 		"enable_message_export":                 *cfg.MessageExportSettings.EnableExport,
 		"export_format":                         *cfg.MessageExportSettings.ExportFormat,
 		"daily_run_time":                        *cfg.MessageExportSettings.DailyRunTime,
@@ -917,40 +920,40 @@ func (ts *TelemetryService) trackConfig() {
 		"is_default_global_relay_email_address": isDefault(*cfg.MessageExportSettings.GlobalRelaySettings.EmailAddress, ""),
 		"global_relay_smtp_server_timeout":      *cfg.MessageExportSettings.GlobalRelaySettings.SMTPServerTimeout,
 		"download_export_results":               *cfg.MessageExportSettings.DownloadExportResults,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigDisplay, map[string]any{
+	configs[TrackConfigDisplay] = map[string]any{
 		"isdefault_custom_url_schemes": len(cfg.DisplaySettings.CustomURLSchemes) != 0,
 		"isdefault_max_markdown_nodes": isDefault(*cfg.DisplaySettings.MaxMarkdownNodes, 0),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigGuestAccounts, map[string]any{
+	configs[TrackConfigGuestAccounts] = map[string]any{
 		"enable":                                 *cfg.GuestAccountsSettings.Enable,
 		"hide_tag":                               *cfg.GuestAccountsSettings.HideTags,
 		"allow_email_accounts":                   *cfg.GuestAccountsSettings.AllowEmailAccounts,
 		"enforce_multifactor_authentication":     *cfg.GuestAccountsSettings.EnforceMultifactorAuthentication,
 		"isdefault_restrict_creation_to_domains": isDefault(*cfg.GuestAccountsSettings.RestrictCreationToDomains, ""),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigImageProxy, map[string]any{
+	configs[TrackConfigImageProxy] = map[string]any{
 		"enable":                               *cfg.ImageProxySettings.Enable,
 		"image_proxy_type":                     *cfg.ImageProxySettings.ImageProxyType,
 		"isdefault_remote_image_proxy_url":     isDefault(*cfg.ImageProxySettings.RemoteImageProxyURL, ""),
 		"isdefault_remote_image_proxy_options": isDefault(*cfg.ImageProxySettings.RemoteImageProxyOptions, ""),
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigBleve, map[string]any{
+	configs[TrackConfigBleve] = map[string]any{
 		"enable_indexing":          *cfg.BleveSettings.EnableIndexing,
 		"enable_searching":         *cfg.BleveSettings.EnableSearching,
 		"enable_autocomplete":      *cfg.BleveSettings.EnableAutocomplete,
 		"bulk_indexing_batch_size": *cfg.BleveSettings.BatchSize,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigExport, map[string]any{
+	configs[TrackConfigExport] = map[string]any{
 		"retention_days": *cfg.ExportSettings.RetentionDays,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigWrangler, map[string]any{
+	configs[TrackConfigWrangler] = map[string]any{
 		"permitted_wrangler_users":                       cfg.WranglerSettings.PermittedWranglerRoles,
 		"allowed_email_domain":                           cfg.WranglerSettings.AllowedEmailDomain,
 		"move_thread_max_count":                          cfg.WranglerSettings.MoveThreadMaxCount,
@@ -958,14 +961,14 @@ func (ts *TelemetryService) trackConfig() {
 		"move_thread_from_private_channel_enable":        cfg.WranglerSettings.MoveThreadFromPrivateChannelEnable,
 		"move_thread_from_direct_message_channel_enable": cfg.WranglerSettings.MoveThreadFromDirectMessageChannelEnable,
 		"move_thread_from_group_message_channel_enable":  cfg.WranglerSettings.MoveThreadFromGroupMessageChannelEnable,
-	})
+	}
 
-	ts.SendTelemetry(TrackConfigConnectedWorkspaces, map[string]any{
+	configs[TrackConfigConnectedWorkspaces] = map[string]any{
 		"enable_shared_channels":              *cfg.ConnectedWorkspacesSettings.EnableSharedChannels,
 		"enable_remote_cluster_service":       *cfg.ConnectedWorkspacesSettings.EnableRemoteClusterService && cfg.FeatureFlags.EnableRemoteClusterService,
 		"disable_shared_channels_status_sync": *cfg.ConnectedWorkspacesSettings.DisableSharedChannelsStatusSync,
 		"max_posts_per_sync":                  *cfg.ConnectedWorkspacesSettings.MaxPostsPerSync,
-	})
+	}
 
 	// Convert feature flags to map[string]any for sending
 	flags := cfg.FeatureFlags.ToMap()
@@ -973,7 +976,9 @@ func (ts *TelemetryService) trackConfig() {
 	for k, v := range flags {
 		interfaceFlags[k] = v
 	}
-	ts.SendTelemetry(TrackFeatureFlags, interfaceFlags)
+	configs[TrackFeatureFlags] = interfaceFlags
+
+	ts.SendTelemetry(TrackConfigs, configs)
 }
 
 func (ts *TelemetryService) trackLicense() {
@@ -1470,7 +1475,7 @@ func (ts *TelemetryService) Shutdown() error {
 	return nil
 }
 
-func (ts *TelemetryService) trackPluginConfig(cfg *model.Config, marketplaceURL string) {
+func (ts *TelemetryService) trackPluginConfig(configs map[string]any, cfg *model.Config, marketplaceURL string) {
 	pluginConfigData := map[string]any{
 		"enable_nps_survey":             pluginSetting(&cfg.PluginSettings, model.PluginIdNPS, "enablesurvey", true),
 		"enable":                        *cfg.PluginSettings.Enable,
@@ -1551,7 +1556,7 @@ func (ts *TelemetryService) trackPluginConfig(cfg *model.Config, marketplaceURL
 			}
 		}
 	}
-	ts.SendTelemetry(TrackConfigPlugin, pluginConfigData)
+	configs[TrackConfigPlugin] = pluginConfigData
 }
 
 func (ts *TelemetryService) GetAllMarketplacePlugins(marketplaceURL string) ([]*model.BaseMarketplacePlugin, error) {

server/platform/services/telemetry/telemetry_test.go

@@ -489,33 +489,10 @@ func TestRudderTelemetry(t *testing.T) {
 		collectInfo(&info)
 
 		for _, item := range []string{
-			TrackConfigService,
-			TrackConfigTeam,
-			TrackConfigSQL,
-			TrackConfigLog,
-			TrackConfigNotificationLog,
-			TrackConfigFile,
-			TrackConfigRate,
-			TrackConfigEmail,
-			TrackConfigPrivacy,
-			TrackConfigOAuth,
-			TrackConfigLDAP,
-			TrackConfigCompliance,
-			TrackConfigLocalization,
-			TrackConfigSAML,
-			TrackConfigPassword,
-			TrackConfigCluster,
-			TrackConfigMetrics,
-			TrackConfigSupport,
-			TrackConfigNativeApp,
-			TrackConfigExperimental,
-			TrackConfigAnalytics,
-			TrackConfigPlugin,
-			TrackFeatureFlags,
 			TrackActivity,
 			TrackServer,
-			TrackConfigMessageExport,
 			TrackPlugins,
+			TrackConfigs,
 		} {
 			require.Contains(t, info, item)
 		}
@@ -532,39 +509,16 @@ func TestRudderTelemetry(t *testing.T) {
 		collectInfo(&info)
 
 		for _, item := range []string{
-			TrackConfigService,
-			TrackConfigTeam,
-			TrackConfigSQL,
-			TrackConfigLog,
-			TrackConfigNotificationLog,
-			TrackConfigFile,
-			TrackConfigRate,
-			TrackConfigEmail,
-			TrackConfigPrivacy,
-			TrackConfigOAuth,
-			TrackConfigLDAP,
-			TrackConfigCompliance,
-			TrackConfigLocalization,
-			TrackConfigSAML,
-			TrackConfigPassword,
-			TrackConfigCluster,
-			TrackConfigMetrics,
-			TrackConfigSupport,
-			TrackConfigNativeApp,
-			TrackConfigExperimental,
-			TrackConfigAnalytics,
-			TrackConfigPlugin,
-			TrackFeatureFlags,
 			TrackActivity,
 			TrackServer,
-			TrackConfigMessageExport,
 			TrackPlugins,
+			TrackConfigs,
 		} {
 			require.Contains(t, info, item)
 		}
 	})
 	t.Run("Telemetry for Marketplace plugins is returned", func(t *testing.T) {
-		service.trackPluginConfig(service.srv.Config(), marketplaceServer.URL)
+		service.trackPluginConfig(map[string]any{}, service.srv.Config(), marketplaceServer.URL)
 
 		var batches []testBatch
 		collectBatches(t, &batches, pchan)
@@ -585,7 +539,7 @@ func TestRudderTelemetry(t *testing.T) {
 	})
 
 	t.Run("Telemetry for known plugins is returned, if request to Marketplace fails", func(t *testing.T) {
-		service.trackPluginConfig(service.srv.Config(), "http://some.random.invalid.url")
+		service.trackPluginConfig(map[string]any{}, service.srv.Config(), "http://some.random.invalid.url")
 
 		var batches []testBatch
 		collectBatches(t, &batches, pchan)