diff --git a/internal/bridge/bridge.go b/internal/bridge/bridge.go index f633cb0b..2d3ebb16 100644 --- a/internal/bridge/bridge.go +++ b/internal/bridge/bridge.go @@ -283,8 +283,6 @@ func newBridge( updater: updater, installCh: make(chan installJob), - heartbeat: telemetry.NewHeartbeat(1143, 1025, gluonCacheDir, keychain.DefaultHelper), - curVersion: curVersion, newVersion: curVersion, newVersionLock: safe.NewRWMutex(), @@ -309,6 +307,7 @@ func newBridge( } bridge.smtpServer = newSMTPServer(bridge, tlsConfig, logSMTP) + bridge.heartbeat = telemetry.NewHeartbeat(bridge, 1143, 1025, gluonCacheDir, keychain.DefaultHelper) return bridge, nil } diff --git a/internal/bridge/heartbeat.go b/internal/bridge/heartbeat.go index c7ed4b20..da75f3a6 100644 --- a/internal/bridge/heartbeat.go +++ b/internal/bridge/heartbeat.go @@ -19,21 +19,61 @@ package bridge import ( "context" + "encoding/json" + "time" + "github.com/ProtonMail/gluon/reporter" "github.com/ProtonMail/proton-bridge/v3/internal/safe" + "github.com/ProtonMail/proton-bridge/v3/internal/telemetry" "github.com/ProtonMail/proton-bridge/v3/internal/vault" + "github.com/sirupsen/logrus" ) -func (bridge *Bridge) ComputeTelemetry() bool { - var telemetry = true +func (bridge *Bridge) IsTelemetryAvailable() bool { + var flag = true safe.RLock(func() { for _, user := range bridge.users { - telemetry = telemetry && user.IsTelemetryEnabled(context.Background()) + flag = flag && user.IsTelemetryEnabled(context.Background()) } }, bridge.usersLock) - return telemetry + return flag +} + +func (bridge *Bridge) SendHeartbeat(heartbeat *telemetry.HeartbeatData) bool { + data, err := json.Marshal(heartbeat) + if err != nil { + if err := bridge.reporter.ReportMessageWithContext("Cannot parse heartbeat data.", reporter.Context{ + "error": err, + }); err != nil { + logrus.WithError(err).Error("Failed to parse heartbeat data.") + } + return false + } + + var sent = false + + safe.RLock(func() { + if len(bridge.users) > 0 { + for _, user := range bridge.users { + if err := user.SendTelemetry(context.Background(), data); err == nil { + sent = true + break + } + } + } + }, bridge.usersLock) + + return sent +} + +func (bridge *Bridge) GetLastHeartbeatSent() time.Time { + return bridge.vault.GetLastHeartbeatSent() +} + +func (bridge *Bridge) SetLastHeartbeatSent(timestamp time.Time) error { + return bridge.vault.SetLastHeartbeatSent(timestamp) } func (bridge *Bridge) initHeartbeat() { @@ -64,4 +104,6 @@ func (bridge *Bridge) initHeartbeat() { bridge.heartbeat.SetKeyChainPref(val) } bridge.heartbeat.SetPrevVersion(bridge.GetLastVersion().String()) + + bridge.heartbeat.StartSending() } diff --git a/internal/telemetry/heartbeat.go b/internal/telemetry/heartbeat.go index 5ee58fd2..505621c8 100644 --- a/internal/telemetry/heartbeat.go +++ b/internal/telemetry/heartbeat.go @@ -18,127 +18,148 @@ package telemetry import ( + "time" + "github.com/ProtonMail/proton-bridge/v3/internal/updater" + "github.com/sirupsen/logrus" ) -func NewHeartbeat(imapPort, smtpPort int, cacheDir, keychain string) Heartbeat { +func NewHeartbeat(manager HeartbeatManager, imapPort, smtpPort int, cacheDir, keychain string) Heartbeat { heartbeat := Heartbeat{ - Metrics: HeartbeatData{ + log: logrus.WithField("pkg", "telemetry"), + manager: manager, + metrics: HeartbeatData{ MeasurementGroup: "bridge.amy.usage", Event: "bridge_heartbeat", }, - DefaultIMAPPort: imapPort, - DefaultSMTPPort: smtpPort, - DefaultCache: cacheDir, - DefaultKeychain: keychain, + defaultIMAPPort: imapPort, + defaultSMTPPort: smtpPort, + defaultCache: cacheDir, + defaultKeychain: keychain, } return heartbeat } func (heartbeat *Heartbeat) SetRollout(val float64) { - heartbeat.Metrics.Values.Rollout = int(val * 100) + heartbeat.metrics.Values.Rollout = int(val * 100) } func (heartbeat *Heartbeat) SetNbAccount(val int) { - heartbeat.Metrics.Values.NbAccount = val + heartbeat.metrics.Values.NbAccount = val } func (heartbeat *Heartbeat) SetAutoUpdate(val bool) { if val { - heartbeat.Metrics.Dimensions.AutoUpdate = dimensionON + heartbeat.metrics.Dimensions.AutoUpdate = dimensionON } else { - heartbeat.Metrics.Dimensions.AutoUpdate = dimensionOFF + heartbeat.metrics.Dimensions.AutoUpdate = dimensionOFF } } func (heartbeat *Heartbeat) SetAutoStart(val bool) { if val { - heartbeat.Metrics.Dimensions.AutoStart = dimensionON + heartbeat.metrics.Dimensions.AutoStart = dimensionON } else { - heartbeat.Metrics.Dimensions.AutoStart = dimensionOFF + heartbeat.metrics.Dimensions.AutoStart = dimensionOFF } } func (heartbeat *Heartbeat) SetBeta(val updater.Channel) { if val == updater.EarlyChannel { - heartbeat.Metrics.Dimensions.Beta = dimensionON + heartbeat.metrics.Dimensions.Beta = dimensionON } else { - heartbeat.Metrics.Dimensions.Beta = dimensionOFF + heartbeat.metrics.Dimensions.Beta = dimensionOFF } } func (heartbeat *Heartbeat) SetDoh(val bool) { if val { - heartbeat.Metrics.Dimensions.Doh = dimensionON + heartbeat.metrics.Dimensions.Doh = dimensionON } else { - heartbeat.Metrics.Dimensions.Doh = dimensionOFF + heartbeat.metrics.Dimensions.Doh = dimensionOFF } } func (heartbeat *Heartbeat) SetSplitMode(val bool) { if val { - heartbeat.Metrics.Dimensions.SplitMode = dimensionON + heartbeat.metrics.Dimensions.SplitMode = dimensionON } else { - heartbeat.Metrics.Dimensions.SplitMode = dimensionOFF + heartbeat.metrics.Dimensions.SplitMode = dimensionOFF } } func (heartbeat *Heartbeat) SetShowAllMail(val bool) { if val { - heartbeat.Metrics.Dimensions.ShowAllMail = dimensionON + heartbeat.metrics.Dimensions.ShowAllMail = dimensionON } else { - heartbeat.Metrics.Dimensions.ShowAllMail = dimensionOFF + heartbeat.metrics.Dimensions.ShowAllMail = dimensionOFF } } func (heartbeat *Heartbeat) SetIMAPConnectionMode(val bool) { if val { - heartbeat.Metrics.Dimensions.IMAPConnectionMode = dimensionSSL + heartbeat.metrics.Dimensions.IMAPConnectionMode = dimensionSSL } else { - heartbeat.Metrics.Dimensions.IMAPConnectionMode = dimensionStartTLS + heartbeat.metrics.Dimensions.IMAPConnectionMode = dimensionStartTLS } } func (heartbeat *Heartbeat) SetSMTPConnectionMode(val bool) { if val { - heartbeat.Metrics.Dimensions.SMTPConnectionMode = dimensionSSL + heartbeat.metrics.Dimensions.SMTPConnectionMode = dimensionSSL } else { - heartbeat.Metrics.Dimensions.SMTPConnectionMode = dimensionStartTLS + heartbeat.metrics.Dimensions.SMTPConnectionMode = dimensionStartTLS } } func (heartbeat *Heartbeat) SetIMAPPort(val int) { - if val == heartbeat.DefaultIMAPPort { - heartbeat.Metrics.Dimensions.IMAPPort = dimensionDefault + if val == heartbeat.defaultIMAPPort { + heartbeat.metrics.Dimensions.IMAPPort = dimensionDefault } else { - heartbeat.Metrics.Dimensions.IMAPPort = dimensionCustom + heartbeat.metrics.Dimensions.IMAPPort = dimensionCustom } } func (heartbeat *Heartbeat) SetSMTPPort(val int) { - if val == heartbeat.DefaultSMTPPort { - heartbeat.Metrics.Dimensions.SMTPPort = dimensionDefault + if val == heartbeat.defaultSMTPPort { + heartbeat.metrics.Dimensions.SMTPPort = dimensionDefault } else { - heartbeat.Metrics.Dimensions.SMTPPort = dimensionCustom + heartbeat.metrics.Dimensions.SMTPPort = dimensionCustom } } func (heartbeat *Heartbeat) SetCacheLocation(val string) { - if val != heartbeat.DefaultCache { - heartbeat.Metrics.Dimensions.CacheLocation = dimensionDefault + if val != heartbeat.defaultCache { + heartbeat.metrics.Dimensions.CacheLocation = dimensionDefault } else { - heartbeat.Metrics.Dimensions.CacheLocation = dimensionCustom + heartbeat.metrics.Dimensions.CacheLocation = dimensionCustom } } func (heartbeat *Heartbeat) SetKeyChainPref(val string) { - if val != heartbeat.DefaultKeychain { - heartbeat.Metrics.Dimensions.KeychainPref = dimensionDefault + if val != heartbeat.defaultKeychain { + heartbeat.metrics.Dimensions.KeychainPref = dimensionDefault } else { - heartbeat.Metrics.Dimensions.KeychainPref = dimensionCustom + heartbeat.metrics.Dimensions.KeychainPref = dimensionCustom } } func (heartbeat *Heartbeat) SetPrevVersion(val string) { - heartbeat.Metrics.Dimensions.PrevVersion = val + heartbeat.metrics.Dimensions.PrevVersion = val +} + +func (heartbeat *Heartbeat) StartSending() { + if heartbeat.manager.IsTelemetryAvailable() { + lastSent := heartbeat.manager.GetLastHeartbeatSent() + now := time.Now() + if now.Year() >= lastSent.Year() && now.YearDay() > lastSent.YearDay() { + if !heartbeat.manager.SendHeartbeat(&heartbeat.metrics) { + heartbeat.log.WithFields(logrus.Fields{ + "metrics": heartbeat.metrics, + }).Error("Failed to send heartbeat") + } else if err := heartbeat.manager.SetLastHeartbeatSent(now); err != nil { + heartbeat.log.WithError(err).Warn("Cannot save last heartbeat sent to the vault.") + } + } + } } diff --git a/internal/telemetry/heartbeat_type.go b/internal/telemetry/types_heartbeat.go similarity index 82% rename from internal/telemetry/heartbeat_type.go rename to internal/telemetry/types_heartbeat.go index 604c5a38..ed9d2828 100644 --- a/internal/telemetry/heartbeat_type.go +++ b/internal/telemetry/types_heartbeat.go @@ -17,6 +17,12 @@ package telemetry +import ( + "time" + + "github.com/sirupsen/logrus" +) + const ( dimensionON = "on" dimensionOFF = "off" @@ -26,6 +32,13 @@ const ( dimensionStartTLS = "starttls" ) +type HeartbeatManager interface { + IsTelemetryAvailable() bool + SendHeartbeat(heartbeat *HeartbeatData) bool + GetLastHeartbeatSent() time.Time + SetLastHeartbeatSent(time.Time) error +} + type HeartbeatValues struct { Rollout int `json:"rollout"` NbAccount int `json:"nb_account"` @@ -55,10 +68,12 @@ type HeartbeatData struct { } type Heartbeat struct { - Metrics HeartbeatData + log *logrus.Entry + manager HeartbeatManager + metrics HeartbeatData - DefaultIMAPPort int - DefaultSMTPPort int - DefaultCache string - DefaultKeychain string + defaultIMAPPort int + defaultSMTPPort int + defaultCache string + defaultKeychain string } diff --git a/internal/user/user.go b/internal/user/user.go index b3d4cd0b..f82d3fd8 100644 --- a/internal/user/user.go +++ b/internal/user/user.go @@ -607,6 +607,31 @@ func (user *User) IsTelemetryEnabled(ctx context.Context) bool { return settings.Telemetry == proton.SettingEnabled } +// SendTelemetry send telemetry request. +func (user *User) SendTelemetry(ctx context.Context, data []byte) error { + var req proton.SendStatsReq + if err := json.Unmarshal(data, &req); err != nil { + user.log.WithError(err).Warn("Failed to send telemetry.") + if err := user.reporter.ReportMessageWithContext("Failed to send telemetry.", reporter.Context{ + "error": err, + }); err != nil { + logrus.WithError(err).Error("Failed to report telemetry sending error") + } + return err + } + err := user.client.SendDataEvent(ctx, req) + if err != nil { + user.log.WithError(err).Warn("Failed to send telemetry.") + if err := user.reporter.ReportMessageWithContext("Failed to send telemetry.", reporter.Context{ + "error": err, + }); err != nil { + logrus.WithError(err).Error("Failed to report telemetry sending error") + } + return err + } + return nil +} + // initUpdateCh initializes the user's update channels in the given address mode. // It is assumed that user.apiAddrs and user.updateCh are already locked. func (user *User) initUpdateCh(mode vault.AddressMode) { diff --git a/internal/vault/settings.go b/internal/vault/settings.go index e09bdc06..f625825e 100644 --- a/internal/vault/settings.go +++ b/internal/vault/settings.go @@ -20,6 +20,7 @@ package vault import ( "math" "math/rand" + "time" "github.com/Masterminds/semver/v3" "github.com/ProtonMail/proton-bridge/v3/internal/updater" @@ -256,3 +257,15 @@ func (vault *Vault) SetLastUserAgent(userAgent string) error { data.Settings.LastUserAgent = userAgent }) } + +// GetLastHeartbeatSent returns the last time heartbeat was sent. +func (vault *Vault) GetLastHeartbeatSent() time.Time { + return vault.get().Settings.LastHeartbeatSent +} + +// SetLastHeartbeatSent store the last time heartbeat was sent. +func (vault *Vault) SetLastHeartbeatSent(timestamp time.Time) error { + return vault.mod(func(data *Data) { + data.Settings.LastHeartbeatSent = timestamp + }) +} diff --git a/internal/vault/types_settings.go b/internal/vault/types_settings.go index 7139c40a..d6961673 100644 --- a/internal/vault/types_settings.go +++ b/internal/vault/types_settings.go @@ -20,6 +20,7 @@ package vault import ( "math/rand" "runtime" + "time" "github.com/ProtonMail/proton-bridge/v3/internal/updater" "github.com/ProtonMail/proton-bridge/v3/pkg/ports" @@ -50,6 +51,8 @@ type Settings struct { LastUserAgent string + LastHeartbeatSent time.Time + // **WARNING**: These entry can't be removed until they vault has proper migration support. SyncWorkers int SyncAttPool int @@ -100,6 +103,7 @@ func newDefaultSettings(gluonDir string) Settings { SyncWorkers: syncWorkers, SyncAttPool: syncWorkers, - LastUserAgent: DefaultUserAgent, + LastUserAgent: DefaultUserAgent, + LastHeartbeatSent: time.Time{}, } } diff --git a/tests/bridge_test.go b/tests/bridge_test.go index ca5b5522..87c719e9 100644 --- a/tests/bridge_test.go +++ b/tests/bridge_test.go @@ -295,7 +295,7 @@ func (s *scenario) bridgeTelemetryFeatureDisabled() error { } func (s *scenario) checkTelemetry(expect bool) error { - res := s.t.bridge.ComputeTelemetry() + res := s.t.bridge.IsTelemetryAvailable() if res != expect { return fmt.Errorf("expected telemetry feature %v but got %v ", expect, res) }