feat(GODT-2552): Send first heartbeat.

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
 }

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 {
+func (bridge *Bridge) IsTelemetryAvailable() bool {
-	var telemetry = true
+	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()
 }

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,
+		defaultIMAPPort: imapPort,
-		DefaultSMTPPort: smtpPort,
+		defaultSMTPPort: smtpPort,
-		DefaultCache:    cacheDir,
+		defaultCache:    cacheDir,
-		DefaultKeychain: keychain,
+		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 {
+	if val == heartbeat.defaultIMAPPort {
-		heartbeat.Metrics.Dimensions.IMAPPort = dimensionDefault
+		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 {
+	if val == heartbeat.defaultSMTPPort {
-		heartbeat.Metrics.Dimensions.SMTPPort = dimensionDefault
+		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 {
+	if val != heartbeat.defaultCache {
-		heartbeat.Metrics.Dimensions.CacheLocation = dimensionDefault
+		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 {
+	if val != heartbeat.defaultKeychain {
-		heartbeat.Metrics.Dimensions.KeychainPref = dimensionDefault
+		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.")
+			}
+		}
+	}
 }

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
+	defaultIMAPPort int
-	DefaultSMTPPort int
+	defaultSMTPPort int
-	DefaultCache    string
+	defaultCache    string
-	DefaultKeychain string
+	defaultKeychain string
 }

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

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

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

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