summaryrefslogtreecommitdiffstats
path: root/app/diagnostics.go
blob: 9e5742111f94f4023e4cccce3a98646843eb7122 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.

package app

import (
	"encoding/json"
	"log"
	"os"
	"runtime"

	"github.com/mattermost/mattermost-server/model"
	"github.com/mattermost/mattermost-server/utils"
	"github.com/segmentio/analytics-go"
)

const (
	SEGMENT_KEY = "fwb7VPbFeQ7SKp3wHm1RzFUuXZudqVok"

	TRACK_CONFIG_SERVICE        = "config_service"
	TRACK_CONFIG_TEAM           = "config_team"
	TRACK_CONFIG_CLIENT_REQ     = "config_client_requirements"
	TRACK_CONFIG_SQL            = "config_sql"
	TRACK_CONFIG_LOG            = "config_log"
	TRACK_CONFIG_FILE           = "config_file"
	TRACK_CONFIG_RATE           = "config_rate"
	TRACK_CONFIG_EMAIL          = "config_email"
	TRACK_CONFIG_PRIVACY        = "config_privacy"
	TRACK_CONFIG_THEME          = "config_theme"
	TRACK_CONFIG_OAUTH          = "config_oauth"
	TRACK_CONFIG_LDAP           = "config_ldap"
	TRACK_CONFIG_COMPLIANCE     = "config_compliance"
	TRACK_CONFIG_LOCALIZATION   = "config_localization"
	TRACK_CONFIG_SAML           = "config_saml"
	TRACK_CONFIG_PASSWORD       = "config_password"
	TRACK_CONFIG_CLUSTER        = "config_cluster"
	TRACK_CONFIG_METRICS        = "config_metrics"
	TRACK_CONFIG_WEBRTC         = "config_webrtc"
	TRACK_CONFIG_SUPPORT        = "config_support"
	TRACK_CONFIG_NATIVEAPP      = "config_nativeapp"
	TRACK_CONFIG_ANALYTICS      = "config_analytics"
	TRACK_CONFIG_ANNOUNCEMENT   = "config_announcement"
	TRACK_CONFIG_ELASTICSEARCH  = "config_elasticsearch"
	TRACK_CONFIG_PLUGIN         = "config_plugin"
	TRACK_CONFIG_DATA_RETENTION = "config_data_retention"

	TRACK_ACTIVITY = "activity"
	TRACK_LICENSE  = "license"
	TRACK_SERVER   = "server"
)

var client *analytics.Client

func (a *App) SendDailyDiagnostics() {
	if *utils.Cfg.LogSettings.EnableDiagnostics && a.IsLeader() {
		initDiagnostics("")
		a.trackActivity()
		trackConfig()
		trackLicense()
		a.trackServer()
	}
}

func initDiagnostics(endpoint string) {
	if client == nil {
		client = analytics.New(SEGMENT_KEY)
		// For testing
		if endpoint != "" {
			client.Endpoint = endpoint
			client.Verbose = true
			client.Size = 1
			client.Logger = log.New(os.Stdout, "segment ", log.LstdFlags)
		}
		client.Identify(&analytics.Identify{
			UserId: utils.CfgDiagnosticId,
		})
	}
}

func SendDiagnostic(event string, properties map[string]interface{}) {
	client.Track(&analytics.Track{
		Event:      event,
		UserId:     utils.CfgDiagnosticId,
		Properties: properties,
	})
}

func isDefault(setting interface{}, defaultValue interface{}) bool {
	if setting == defaultValue {
		return true
	}
	return false
}

func pluginSetting(plugin, key string, defaultValue interface{}) interface{} {
	settings, ok := utils.Cfg.PluginSettings.Plugins[plugin]
	if !ok {
		return defaultValue
	}
	var m map[string]interface{}
	if b, err := json.Marshal(settings); err != nil {
		return defaultValue
	} else {
		json.Unmarshal(b, &m)
	}
	if value, ok := m[key]; ok {
		return value
	}
	return defaultValue
}

func (a *App) trackActivity() {
	var userCount int64
	var activeUserCount int64
	var inactiveUserCount int64
	var teamCount int64
	var publicChannelCount int64
	var privateChannelCount int64
	var directChannelCount int64
	var deletedPublicChannelCount int64
	var deletedPrivateChannelCount int64
	var postsCount int64

	if ucr := <-a.Srv.Store.User().GetTotalUsersCount(); ucr.Err == nil {
		userCount = ucr.Data.(int64)
	}

	if ucr := <-a.Srv.Store.Status().GetTotalActiveUsersCount(); ucr.Err == nil {
		activeUserCount = ucr.Data.(int64)
	}

	if iucr := <-a.Srv.Store.Status().GetTotalActiveUsersCount(); iucr.Err == nil {
		inactiveUserCount = iucr.Data.(int64)
	}

	if tcr := <-a.Srv.Store.Team().AnalyticsTeamCount(); tcr.Err == nil {
		teamCount = tcr.Data.(int64)
	}

	if ucc := <-a.Srv.Store.Channel().AnalyticsTypeCount("", "O"); ucc.Err == nil {
		publicChannelCount = ucc.Data.(int64)
	}

	if pcc := <-a.Srv.Store.Channel().AnalyticsTypeCount("", "P"); pcc.Err == nil {
		privateChannelCount = pcc.Data.(int64)
	}

	if dcc := <-a.Srv.Store.Channel().AnalyticsTypeCount("", "D"); dcc.Err == nil {
		directChannelCount = dcc.Data.(int64)
	}

	if duccr := <-a.Srv.Store.Channel().AnalyticsDeletedTypeCount("", "O"); duccr.Err == nil {
		deletedPublicChannelCount = duccr.Data.(int64)
	}

	if dpccr := <-a.Srv.Store.Channel().AnalyticsDeletedTypeCount("", "P"); dpccr.Err == nil {
		deletedPrivateChannelCount = dpccr.Data.(int64)
	}

	if pcr := <-a.Srv.Store.Post().AnalyticsPostCount("", false, false); pcr.Err == nil {
		postsCount = pcr.Data.(int64)
	}

	SendDiagnostic(TRACK_ACTIVITY, map[string]interface{}{
		"registered_users":          userCount,
		"active_users":              activeUserCount,
		"registered_inactive_users": inactiveUserCount,
		"teams":                     teamCount,
		"public_channels":           publicChannelCount,
		"private_channels":          privateChannelCount,
		"direct_message_channels":   directChannelCount,
		"public_channels_deleted":   deletedPublicChannelCount,
		"private_channels_deleted":  deletedPrivateChannelCount,
		"posts":                     postsCount,
	})
}

func trackConfig() {
	SendDiagnostic(TRACK_CONFIG_SERVICE, map[string]interface{}{
		"web_server_mode":                                  *utils.Cfg.ServiceSettings.WebserverMode,
		"enable_security_fix_alert":                        *utils.Cfg.ServiceSettings.EnableSecurityFixAlert,
		"enable_insecure_outgoing_connections":             *utils.Cfg.ServiceSettings.EnableInsecureOutgoingConnections,
		"enable_incoming_webhooks":                         utils.Cfg.ServiceSettings.EnableIncomingWebhooks,
		"enable_outgoing_webhooks":                         utils.Cfg.ServiceSettings.EnableOutgoingWebhooks,
		"enable_commands":                                  *utils.Cfg.ServiceSettings.EnableCommands,
		"enable_only_admin_integrations":                   *utils.Cfg.ServiceSettings.EnableOnlyAdminIntegrations,
		"enable_post_username_override":                    utils.Cfg.ServiceSettings.EnablePostUsernameOverride,
		"enable_post_icon_override":                        utils.Cfg.ServiceSettings.EnablePostIconOverride,
		"enable_apiv3":                                     *utils.Cfg.ServiceSettings.EnableAPIv3,
		"enable_user_access_tokens":                        *utils.Cfg.ServiceSettings.EnableUserAccessTokens,
		"enable_custom_emoji":                              *utils.Cfg.ServiceSettings.EnableCustomEmoji,
		"enable_emoji_picker":                              *utils.Cfg.ServiceSettings.EnableEmojiPicker,
		"restrict_custom_emoji_creation":                   *utils.Cfg.ServiceSettings.RestrictCustomEmojiCreation,
		"enable_testing":                                   utils.Cfg.ServiceSettings.EnableTesting,
		"enable_developer":                                 *utils.Cfg.ServiceSettings.EnableDeveloper,
		"enable_multifactor_authentication":                *utils.Cfg.ServiceSettings.EnableMultifactorAuthentication,
		"enforce_multifactor_authentication":               *utils.Cfg.ServiceSettings.EnforceMultifactorAuthentication,
		"enable_oauth_service_provider":                    utils.Cfg.ServiceSettings.EnableOAuthServiceProvider,
		"connection_security":                              *utils.Cfg.ServiceSettings.ConnectionSecurity,
		"uses_letsencrypt":                                 *utils.Cfg.ServiceSettings.UseLetsEncrypt,
		"forward_80_to_443":                                *utils.Cfg.ServiceSettings.Forward80To443,
		"maximum_login_attempts":                           *utils.Cfg.ServiceSettings.MaximumLoginAttempts,
		"session_length_web_in_days":                       *utils.Cfg.ServiceSettings.SessionLengthWebInDays,
		"session_length_mobile_in_days":                    *utils.Cfg.ServiceSettings.SessionLengthMobileInDays,
		"session_length_sso_in_days":                       *utils.Cfg.ServiceSettings.SessionLengthSSOInDays,
		"session_cache_in_minutes":                         *utils.Cfg.ServiceSettings.SessionCacheInMinutes,
		"isdefault_site_url":                               isDefault(*utils.Cfg.ServiceSettings.SiteURL, model.SERVICE_SETTINGS_DEFAULT_SITE_URL),
		"isdefault_tls_cert_file":                          isDefault(*utils.Cfg.ServiceSettings.TLSCertFile, model.SERVICE_SETTINGS_DEFAULT_TLS_CERT_FILE),
		"isdefault_tls_key_file":                           isDefault(*utils.Cfg.ServiceSettings.TLSKeyFile, model.SERVICE_SETTINGS_DEFAULT_TLS_KEY_FILE),
		"isdefault_read_timeout":                           isDefault(*utils.Cfg.ServiceSettings.ReadTimeout, model.SERVICE_SETTINGS_DEFAULT_READ_TIMEOUT),
		"isdefault_write_timeout":                          isDefault(*utils.Cfg.ServiceSettings.WriteTimeout, model.SERVICE_SETTINGS_DEFAULT_WRITE_TIMEOUT),
		"isdefault_google_developer_key":                   isDefault(utils.Cfg.ServiceSettings.GoogleDeveloperKey, ""),
		"isdefault_allow_cors_from":                        isDefault(*utils.Cfg.ServiceSettings.AllowCorsFrom, model.SERVICE_SETTINGS_DEFAULT_ALLOW_CORS_FROM),
		"isdefault_allowed_untrusted_internal_connections": isDefault(*utils.Cfg.ServiceSettings.AllowedUntrustedInternalConnections, ""),
		"restrict_post_delete":                             *utils.Cfg.ServiceSettings.RestrictPostDelete,
		"allow_edit_post":                                  *utils.Cfg.ServiceSettings.AllowEditPost,
		"post_edit_time_limit":                             *utils.Cfg.ServiceSettings.PostEditTimeLimit,
		"enable_user_typing_messages":                      *utils.Cfg.ServiceSettings.EnableUserTypingMessages,
		"enable_channel_viewed_messages":                   *utils.Cfg.ServiceSettings.EnableChannelViewedMessages,
		"time_between_user_typing_updates_milliseconds":    *utils.Cfg.ServiceSettings.TimeBetweenUserTypingUpdatesMilliseconds,
		"cluster_log_timeout_milliseconds":                 *utils.Cfg.ServiceSettings.ClusterLogTimeoutMilliseconds,
		"enable_post_search":                               *utils.Cfg.ServiceSettings.EnablePostSearch,
		"enable_user_statuses":                             *utils.Cfg.ServiceSettings.EnableUserStatuses,
	})

	SendDiagnostic(TRACK_CONFIG_TEAM, map[string]interface{}{
		"enable_user_creation":                    utils.Cfg.TeamSettings.EnableUserCreation,
		"enable_team_creation":                    utils.Cfg.TeamSettings.EnableTeamCreation,
		"restrict_team_invite":                    *utils.Cfg.TeamSettings.RestrictTeamInvite,
		"restrict_public_channel_creation":        *utils.Cfg.TeamSettings.RestrictPublicChannelCreation,
		"restrict_private_channel_creation":       *utils.Cfg.TeamSettings.RestrictPrivateChannelCreation,
		"restrict_public_channel_management":      *utils.Cfg.TeamSettings.RestrictPublicChannelManagement,
		"restrict_private_channel_management":     *utils.Cfg.TeamSettings.RestrictPrivateChannelManagement,
		"restrict_public_channel_deletion":        *utils.Cfg.TeamSettings.RestrictPublicChannelDeletion,
		"restrict_private_channel_deletion":       *utils.Cfg.TeamSettings.RestrictPrivateChannelDeletion,
		"enable_open_server":                      *utils.Cfg.TeamSettings.EnableOpenServer,
		"enable_custom_brand":                     *utils.Cfg.TeamSettings.EnableCustomBrand,
		"restrict_direct_message":                 *utils.Cfg.TeamSettings.RestrictDirectMessage,
		"max_notifications_per_channel":           *utils.Cfg.TeamSettings.MaxNotificationsPerChannel,
		"enable_confirm_notifications_to_channel": *utils.Cfg.TeamSettings.EnableConfirmNotificationsToChannel,
		"max_users_per_team":                      *utils.Cfg.TeamSettings.MaxUsersPerTeam,
		"max_channels_per_team":                   *utils.Cfg.TeamSettings.MaxChannelsPerTeam,
		"teammate_name_display":                   *utils.Cfg.TeamSettings.TeammateNameDisplay,
		"isdefault_site_name":                     isDefault(utils.Cfg.TeamSettings.SiteName, "Mattermost"),
		"isdefault_custom_brand_text":             isDefault(*utils.Cfg.TeamSettings.CustomBrandText, model.TEAM_SETTINGS_DEFAULT_CUSTOM_BRAND_TEXT),
		"isdefault_custom_description_text":       isDefault(*utils.Cfg.TeamSettings.CustomDescriptionText, model.TEAM_SETTINGS_DEFAULT_CUSTOM_DESCRIPTION_TEXT),
		"isdefault_user_status_away_timeout":      isDefault(*utils.Cfg.TeamSettings.UserStatusAwayTimeout, model.TEAM_SETTINGS_DEFAULT_USER_STATUS_AWAY_TIMEOUT),
		"restrict_private_channel_manage_members": *utils.Cfg.TeamSettings.RestrictPrivateChannelManageMembers,
		"enable_X_to_leave_channels_from_LHS":     *utils.Cfg.TeamSettings.EnableXToLeaveChannelsFromLHS,
		"experimental_town_square_is_read_only":   *utils.Cfg.TeamSettings.ExperimentalTownSquareIsReadOnly,
	})

	SendDiagnostic(TRACK_CONFIG_CLIENT_REQ, map[string]interface{}{
		"android_latest_version": utils.Cfg.ClientRequirements.AndroidLatestVersion,
		"android_min_version":    utils.Cfg.ClientRequirements.AndroidMinVersion,
		"desktop_latest_version": utils.Cfg.ClientRequirements.DesktopLatestVersion,
		"desktop_min_version":    utils.Cfg.ClientRequirements.DesktopMinVersion,
		"ios_latest_version":     utils.Cfg.ClientRequirements.IosLatestVersion,
		"ios_min_version":        utils.Cfg.ClientRequirements.IosMinVersion,
	})

	SendDiagnostic(TRACK_CONFIG_SQL, map[string]interface{}{
		"driver_name":                 *utils.Cfg.SqlSettings.DriverName,
		"trace":                       utils.Cfg.SqlSettings.Trace,
		"max_idle_conns":              *utils.Cfg.SqlSettings.MaxIdleConns,
		"max_open_conns":              *utils.Cfg.SqlSettings.MaxOpenConns,
		"data_source_replicas":        len(utils.Cfg.SqlSettings.DataSourceReplicas),
		"data_source_search_replicas": len(utils.Cfg.SqlSettings.DataSourceSearchReplicas),
		"query_timeout":               *utils.Cfg.SqlSettings.QueryTimeout,
	})

	SendDiagnostic(TRACK_CONFIG_LOG, map[string]interface{}{
		"enable_console":           utils.Cfg.LogSettings.EnableConsole,
		"console_level":            utils.Cfg.LogSettings.ConsoleLevel,
		"enable_file":              utils.Cfg.LogSettings.EnableFile,
		"file_level":               utils.Cfg.LogSettings.FileLevel,
		"enable_webhook_debugging": utils.Cfg.LogSettings.EnableWebhookDebugging,
		"isdefault_file_format":    isDefault(utils.Cfg.LogSettings.FileFormat, ""),
		"isdefault_file_location":  isDefault(utils.Cfg.LogSettings.FileLocation, ""),
	})

	SendDiagnostic(TRACK_CONFIG_PASSWORD, map[string]interface{}{
		"minimum_length": *utils.Cfg.PasswordSettings.MinimumLength,
		"lowercase":      *utils.Cfg.PasswordSettings.Lowercase,
		"number":         *utils.Cfg.PasswordSettings.Number,
		"uppercase":      *utils.Cfg.PasswordSettings.Uppercase,
		"symbol":         *utils.Cfg.PasswordSettings.Symbol,
	})

	SendDiagnostic(TRACK_CONFIG_FILE, map[string]interface{}{
		"enable_public_links":     utils.Cfg.FileSettings.EnablePublicLink,
		"driver_name":             *utils.Cfg.FileSettings.DriverName,
		"amazon_s3_ssl":           *utils.Cfg.FileSettings.AmazonS3SSL,
		"amazon_s3_sse":           *utils.Cfg.FileSettings.AmazonS3SSE,
		"amazon_s3_signv2":        *utils.Cfg.FileSettings.AmazonS3SignV2,
		"amazon_s3_trace":         *utils.Cfg.FileSettings.AmazonS3Trace,
		"max_file_size":           *utils.Cfg.FileSettings.MaxFileSize,
		"enable_file_attachments": *utils.Cfg.FileSettings.EnableFileAttachments,
		"enable_mobile_upload":    *utils.Cfg.FileSettings.EnableMobileUpload,
		"enable_mobile_download":  *utils.Cfg.FileSettings.EnableMobileDownload,
	})

	SendDiagnostic(TRACK_CONFIG_EMAIL, map[string]interface{}{
		"enable_sign_up_with_email":            utils.Cfg.EmailSettings.EnableSignUpWithEmail,
		"enable_sign_in_with_email":            *utils.Cfg.EmailSettings.EnableSignInWithEmail,
		"enable_sign_in_with_username":         *utils.Cfg.EmailSettings.EnableSignInWithUsername,
		"require_email_verification":           utils.Cfg.EmailSettings.RequireEmailVerification,
		"send_email_notifications":             utils.Cfg.EmailSettings.SendEmailNotifications,
		"email_notification_contents_type":     *utils.Cfg.EmailSettings.EmailNotificationContentsType,
		"enable_smtp_auth":                     *utils.Cfg.EmailSettings.EnableSMTPAuth,
		"connection_security":                  utils.Cfg.EmailSettings.ConnectionSecurity,
		"send_push_notifications":              *utils.Cfg.EmailSettings.SendPushNotifications,
		"push_notification_contents":           *utils.Cfg.EmailSettings.PushNotificationContents,
		"enable_email_batching":                *utils.Cfg.EmailSettings.EnableEmailBatching,
		"email_batching_buffer_size":           *utils.Cfg.EmailSettings.EmailBatchingBufferSize,
		"email_batching_interval":              *utils.Cfg.EmailSettings.EmailBatchingInterval,
		"isdefault_feedback_name":              isDefault(utils.Cfg.EmailSettings.FeedbackName, ""),
		"isdefault_feedback_email":             isDefault(utils.Cfg.EmailSettings.FeedbackEmail, ""),
		"isdefault_feedback_organization":      isDefault(*utils.Cfg.EmailSettings.FeedbackOrganization, model.EMAIL_SETTINGS_DEFAULT_FEEDBACK_ORGANIZATION),
		"skip_server_certificate_verification": *utils.Cfg.EmailSettings.SkipServerCertificateVerification,
	})

	SendDiagnostic(TRACK_CONFIG_RATE, map[string]interface{}{
		"enable_rate_limiter":      *utils.Cfg.RateLimitSettings.Enable,
		"vary_by_remote_address":   utils.Cfg.RateLimitSettings.VaryByRemoteAddr,
		"per_sec":                  *utils.Cfg.RateLimitSettings.PerSec,
		"max_burst":                *utils.Cfg.RateLimitSettings.MaxBurst,
		"memory_store_size":        *utils.Cfg.RateLimitSettings.MemoryStoreSize,
		"isdefault_vary_by_header": isDefault(utils.Cfg.RateLimitSettings.VaryByHeader, ""),
	})

	SendDiagnostic(TRACK_CONFIG_PRIVACY, map[string]interface{}{
		"show_email_address": utils.Cfg.PrivacySettings.ShowEmailAddress,
		"show_full_name":     utils.Cfg.PrivacySettings.ShowFullName,
	})

	SendDiagnostic(TRACK_CONFIG_THEME, map[string]interface{}{
		"enable_theme_selection":  *utils.Cfg.ThemeSettings.EnableThemeSelection,
		"isdefault_default_theme": isDefault(*utils.Cfg.ThemeSettings.DefaultTheme, model.TEAM_SETTINGS_DEFAULT_TEAM_TEXT),
		"allow_custom_themes":     *utils.Cfg.ThemeSettings.AllowCustomThemes,
		"allowed_themes":          len(utils.Cfg.ThemeSettings.AllowedThemes),
	})

	SendDiagnostic(TRACK_CONFIG_OAUTH, map[string]interface{}{
		"enable_gitlab":    utils.Cfg.GitLabSettings.Enable,
		"enable_google":    utils.Cfg.GoogleSettings.Enable,
		"enable_office365": utils.Cfg.Office365Settings.Enable,
	})

	SendDiagnostic(TRACK_CONFIG_SUPPORT, map[string]interface{}{
		"isdefault_terms_of_service_link": isDefault(*utils.Cfg.SupportSettings.TermsOfServiceLink, model.SUPPORT_SETTINGS_DEFAULT_TERMS_OF_SERVICE_LINK),
		"isdefault_privacy_policy_link":   isDefault(*utils.Cfg.SupportSettings.PrivacyPolicyLink, model.SUPPORT_SETTINGS_DEFAULT_PRIVACY_POLICY_LINK),
		"isdefault_about_link":            isDefault(*utils.Cfg.SupportSettings.AboutLink, model.SUPPORT_SETTINGS_DEFAULT_ABOUT_LINK),
		"isdefault_help_link":             isDefault(*utils.Cfg.SupportSettings.HelpLink, model.SUPPORT_SETTINGS_DEFAULT_HELP_LINK),
		"isdefault_report_a_problem_link": isDefault(*utils.Cfg.SupportSettings.ReportAProblemLink, model.SUPPORT_SETTINGS_DEFAULT_REPORT_A_PROBLEM_LINK),
		"isdefault_support_email":         isDefault(*utils.Cfg.SupportSettings.SupportEmail, model.SUPPORT_SETTINGS_DEFAULT_SUPPORT_EMAIL),
	})

	SendDiagnostic(TRACK_CONFIG_LDAP, map[string]interface{}{
		"enable":                         *utils.Cfg.LdapSettings.Enable,
		"connection_security":            *utils.Cfg.LdapSettings.ConnectionSecurity,
		"skip_certificate_verification":  *utils.Cfg.LdapSettings.SkipCertificateVerification,
		"sync_interval_minutes":          *utils.Cfg.LdapSettings.SyncIntervalMinutes,
		"query_timeout":                  *utils.Cfg.LdapSettings.QueryTimeout,
		"max_page_size":                  *utils.Cfg.LdapSettings.MaxPageSize,
		"isdefault_first_name_attribute": isDefault(*utils.Cfg.LdapSettings.FirstNameAttribute, model.LDAP_SETTINGS_DEFAULT_FIRST_NAME_ATTRIBUTE),
		"isdefault_last_name_attribute":  isDefault(*utils.Cfg.LdapSettings.LastNameAttribute, model.LDAP_SETTINGS_DEFAULT_LAST_NAME_ATTRIBUTE),
		"isdefault_email_attribute":      isDefault(*utils.Cfg.LdapSettings.EmailAttribute, model.LDAP_SETTINGS_DEFAULT_EMAIL_ATTRIBUTE),
		"isdefault_username_attribute":   isDefault(*utils.Cfg.LdapSettings.UsernameAttribute, model.LDAP_SETTINGS_DEFAULT_USERNAME_ATTRIBUTE),
		"isdefault_nickname_attribute":   isDefault(*utils.Cfg.LdapSettings.NicknameAttribute, model.LDAP_SETTINGS_DEFAULT_NICKNAME_ATTRIBUTE),
		"isdefault_id_attribute":         isDefault(*utils.Cfg.LdapSettings.IdAttribute, model.LDAP_SETTINGS_DEFAULT_ID_ATTRIBUTE),
		"isdefault_position_attribute":   isDefault(*utils.Cfg.LdapSettings.PositionAttribute, model.LDAP_SETTINGS_DEFAULT_POSITION_ATTRIBUTE),
		"isdefault_login_field_name":     isDefault(*utils.Cfg.LdapSettings.LoginFieldName, model.LDAP_SETTINGS_DEFAULT_LOGIN_FIELD_NAME),
	})

	SendDiagnostic(TRACK_CONFIG_COMPLIANCE, map[string]interface{}{
		"enable":       *utils.Cfg.ComplianceSettings.Enable,
		"enable_daily": *utils.Cfg.ComplianceSettings.EnableDaily,
	})

	SendDiagnostic(TRACK_CONFIG_LOCALIZATION, map[string]interface{}{
		"default_server_locale": *utils.Cfg.LocalizationSettings.DefaultServerLocale,
		"default_client_locale": *utils.Cfg.LocalizationSettings.DefaultClientLocale,
		"available_locales":     *utils.Cfg.LocalizationSettings.AvailableLocales,
	})

	SendDiagnostic(TRACK_CONFIG_SAML, map[string]interface{}{
		"enable":                         *utils.Cfg.SamlSettings.Enable,
		"verify":                         *utils.Cfg.SamlSettings.Verify,
		"encrypt":                        *utils.Cfg.SamlSettings.Encrypt,
		"isdefault_first_name_attribute": isDefault(*utils.Cfg.SamlSettings.FirstNameAttribute, model.SAML_SETTINGS_DEFAULT_FIRST_NAME_ATTRIBUTE),
		"isdefault_last_name_attribute":  isDefault(*utils.Cfg.SamlSettings.LastNameAttribute, model.SAML_SETTINGS_DEFAULT_LAST_NAME_ATTRIBUTE),
		"isdefault_email_attribute":      isDefault(*utils.Cfg.SamlSettings.EmailAttribute, model.SAML_SETTINGS_DEFAULT_EMAIL_ATTRIBUTE),
		"isdefault_username_attribute":   isDefault(*utils.Cfg.SamlSettings.UsernameAttribute, model.SAML_SETTINGS_DEFAULT_USERNAME_ATTRIBUTE),
		"isdefault_nickname_attribute":   isDefault(*utils.Cfg.SamlSettings.NicknameAttribute, model.SAML_SETTINGS_DEFAULT_NICKNAME_ATTRIBUTE),
		"isdefault_locale_attribute":     isDefault(*utils.Cfg.SamlSettings.LocaleAttribute, model.SAML_SETTINGS_DEFAULT_LOCALE_ATTRIBUTE),
		"isdefault_position_attribute":   isDefault(*utils.Cfg.SamlSettings.PositionAttribute, model.SAML_SETTINGS_DEFAULT_POSITION_ATTRIBUTE),
		"isdefault_login_button_text":    isDefault(*utils.Cfg.SamlSettings.LoginButtonText, model.USER_AUTH_SERVICE_SAML_TEXT),
	})

	SendDiagnostic(TRACK_CONFIG_CLUSTER, map[string]interface{}{
		"enable":                  *utils.Cfg.ClusterSettings.Enable,
		"use_ip_address":          *utils.Cfg.ClusterSettings.UseIpAddress,
		"use_experimental_gossip": *utils.Cfg.ClusterSettings.UseExperimentalGossip,
		"read_only_config":        *utils.Cfg.ClusterSettings.ReadOnlyConfig,
	})

	SendDiagnostic(TRACK_CONFIG_METRICS, map[string]interface{}{
		"enable":             *utils.Cfg.MetricsSettings.Enable,
		"block_profile_rate": *utils.Cfg.MetricsSettings.BlockProfileRate,
	})

	SendDiagnostic(TRACK_CONFIG_NATIVEAPP, map[string]interface{}{
		"isdefault_app_download_link":         isDefault(*utils.Cfg.NativeAppSettings.AppDownloadLink, model.NATIVEAPP_SETTINGS_DEFAULT_APP_DOWNLOAD_LINK),
		"isdefault_android_app_download_link": isDefault(*utils.Cfg.NativeAppSettings.AndroidAppDownloadLink, model.NATIVEAPP_SETTINGS_DEFAULT_ANDROID_APP_DOWNLOAD_LINK),
		"isdefault_iosapp_download_link":      isDefault(*utils.Cfg.NativeAppSettings.IosAppDownloadLink, model.NATIVEAPP_SETTINGS_DEFAULT_IOS_APP_DOWNLOAD_LINK),
	})

	SendDiagnostic(TRACK_CONFIG_WEBRTC, map[string]interface{}{
		"enable":             *utils.Cfg.WebrtcSettings.Enable,
		"isdefault_stun_uri": isDefault(*utils.Cfg.WebrtcSettings.StunURI, model.WEBRTC_SETTINGS_DEFAULT_STUN_URI),
		"isdefault_turn_uri": isDefault(*utils.Cfg.WebrtcSettings.TurnURI, model.WEBRTC_SETTINGS_DEFAULT_TURN_URI),
	})

	SendDiagnostic(TRACK_CONFIG_ANALYTICS, map[string]interface{}{
		"isdefault_max_users_for_statistics": isDefault(*utils.Cfg.AnalyticsSettings.MaxUsersForStatistics, model.ANALYTICS_SETTINGS_DEFAULT_MAX_USERS_FOR_STATISTICS),
	})

	SendDiagnostic(TRACK_CONFIG_ANNOUNCEMENT, map[string]interface{}{
		"enable_banner":               *utils.Cfg.AnnouncementSettings.EnableBanner,
		"isdefault_banner_color":      isDefault(*utils.Cfg.AnnouncementSettings.BannerColor, model.ANNOUNCEMENT_SETTINGS_DEFAULT_BANNER_COLOR),
		"isdefault_banner_text_color": isDefault(*utils.Cfg.AnnouncementSettings.BannerTextColor, model.ANNOUNCEMENT_SETTINGS_DEFAULT_BANNER_TEXT_COLOR),
		"allow_banner_dismissal":      *utils.Cfg.AnnouncementSettings.AllowBannerDismissal,
	})

	SendDiagnostic(TRACK_CONFIG_ELASTICSEARCH, map[string]interface{}{
		"isdefault_connection_url": isDefault(*utils.Cfg.ElasticsearchSettings.ConnectionUrl, model.ELASTICSEARCH_SETTINGS_DEFAULT_CONNECTION_URL),
		"isdefault_username":       isDefault(*utils.Cfg.ElasticsearchSettings.Username, model.ELASTICSEARCH_SETTINGS_DEFAULT_USERNAME),
		"isdefault_password":       isDefault(*utils.Cfg.ElasticsearchSettings.Password, model.ELASTICSEARCH_SETTINGS_DEFAULT_PASSWORD),
		"enable_indexing":          *utils.Cfg.ElasticsearchSettings.EnableIndexing,
		"enable_searching":         *utils.Cfg.ElasticsearchSettings.EnableSearching,
		"sniff":                    *utils.Cfg.ElasticsearchSettings.Sniff,
		"post_index_replicas":      *utils.Cfg.ElasticsearchSettings.PostIndexReplicas,
		"post_index_shards":        *utils.Cfg.ElasticsearchSettings.PostIndexShards,
	})

	SendDiagnostic(TRACK_CONFIG_PLUGIN, map[string]interface{}{
		"enable_jira": pluginSetting("jira", "enabled", false),
	})

	SendDiagnostic(TRACK_CONFIG_DATA_RETENTION, map[string]interface{}{
		"enable_message_deletion": *utils.Cfg.DataRetentionSettings.EnableMessageDeletion,
		"enable_file_deletion":    *utils.Cfg.DataRetentionSettings.EnableFileDeletion,
		"message_retention_days":  *utils.Cfg.DataRetentionSettings.MessageRetentionDays,
		"file_retention_days":     *utils.Cfg.DataRetentionSettings.FileRetentionDays,
		"deletion_job_start_time": *utils.Cfg.DataRetentionSettings.DeletionJobStartTime,
	})
}

func trackLicense() {
	if utils.IsLicensed() {
		data := map[string]interface{}{
			"customer_id": utils.License().Customer.Id,
			"license_id":  utils.License().Id,
			"issued":      utils.License().IssuedAt,
			"start":       utils.License().StartsAt,
			"expire":      utils.License().ExpiresAt,
			"users":       *utils.License().Features.Users,
		}

		features := utils.License().Features.ToMap()
		for featureName, featureValue := range features {
			data["feature_"+featureName] = featureValue
		}

		SendDiagnostic(TRACK_LICENSE, data)
	}
}

func (a *App) trackServer() {
	data := map[string]interface{}{
		"edition":          model.BuildEnterpriseReady,
		"version":          model.CurrentVersion,
		"database_type":    *utils.Cfg.SqlSettings.DriverName,
		"operating_system": runtime.GOOS,
	}

	if scr := <-a.Srv.Store.User().AnalyticsGetSystemAdminCount(); scr.Err == nil {
		data["system_admins"] = scr.Data.(int64)
	}

	SendDiagnostic(TRACK_SERVER, data)
}