yesBad/proton-bridge
1
0
Fork 0
forked from Silverfish/proton-bridge
Code Actions Activity

feat(GODT-2552): Send first heartbeat.

Browse Source
This commit is contained in:
Romain LE JEUNE
2023-04-18 16:52:15 +02:00
committed by Romain Le Jeune
parent 0f621d0aad
commit b250d49af8
8 changed files with 169 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
internal/bridge/bridge.go
View File

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

50
internal/bridge/heartbeat.go
View File

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

95
internal/telemetry/heartbeat.go
View File

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

25
internal/telemetry/heartbeat_type.go → internal/telemetry/types_heartbeat.go
View File

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

25
internal/user/user.go
View File

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

13
internal/vault/settings.go
View File

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

6
internal/vault/types_settings.go
View File

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

2
tests/bridge_test.go
View File

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