PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FEATURE (telemetry): Add anonymous telemetry (databasus version, arch, etc.)
Rostislav Duginb9940e0d30c1
diff --git a/README.md b/README.mdindex db698a00..fe55de03 100644--- a/README.md+++ b/README.md@@ -302,8 +302,8 @@ We also draw attention to fast issue resolution and security [vulnerability repoYes. Every feature available in Databasus Cloud is equally available in the self-hosted version with no restrictions, no feature gates and no usage limits. The entire codebase is Apache 2.0 licensed and always will be.-Databasus is not "open core." We do not withhold features behind a paid tier and then call the limited remainder "open source," as projects like GitLab or Sentry do. We believe open source means the complete product is open, not just a marketing label on a stripped-down edition.+Databasus is not "open core". We do not withhold features behind a paid tier and then call the limited remainder "open source" as projects like GitLab or Sentry do. We believe open source means the complete product is open, not just a marketing label on a stripped-down edition.Databasus Cloud runs the exact same code as the self-hosted version. The only difference is that we take care of infrastructure, availability, backups, reservations, monitoring and updates for you — so you don't have to. If you are using cloud, you can always move your databases from cloud to self-hosted if you wish.-Revenue from Cloud funds full-time development of the project. Most large open-source projects rely on corporate backing or sponsorship to survive. We chose a different path: Databasus sustains itself so it can grow and improve independently, without being tied to any enterprise or sponsor.+Revenue from Databasus Cloud funds full-time development of the project. Many open-source projects depend on corporate backing, sponsorships or volunteer maintainers, which can create long-term sustainability challenges. Recent discussions around [Tailwind](https://github.com/tailwindlabs/tailwindcss.com/pull/2388#issuecomment-3717222957) and the archival of [pgBackRest](https://github.com/pgbackrest/pgbackrest#notice-of-obsolescence) show that even popular or critical open-source projects need a durable funding model. Databasus Cloud is our way to make the project financially sustainable while keeping the full product open source, self-hostable and independent from any single corporate sponsor.diff --git a/backend/cmd/main.go b/backend/cmd/main.goindex 6dec3421..080586a5 100644--- a/backend/cmd/main.go+++ b/backend/cmd/main.go@@ -3,6 +3,7 @@ package mainimport ("context""flag"+ "fmt""log/slog""net/http""os"@@ -41,6 +42,7 @@ import (system_healthcheck "databasus-backend/internal/features/system/healthcheck"system_version "databasus-backend/internal/features/system/version"task_cancellation "databasus-backend/internal/features/tasks/cancellation"+ "databasus-backend/internal/features/telemetry"users_controllers "databasus-backend/internal/features/users/controllers"users_middleware "databasus-backend/internal/features/users/middleware"users_services "databasus-backend/internal/features/users/services"@@ -125,6 +127,8 @@ func main() {setUpRoutes(ginApp)setUpDependencies()+ announceTelemetry()+runBackgroundTasks(log)mountFrontend(ginApp)@@ -267,6 +271,23 @@ func setUpDependencies() {if config.GetEnv().IsCloud {billing_paddle.SetupDependencies()}++ telemetry.SetupDependencies()+}++func announceTelemetry() {+ if !config.GetEnv().IsPrimaryNode {+ return+ }++ if config.GetEnv().IsDisableAnonymousTelemetry {+ return+ }++ fmt.Println(+ "Anonymous telemetry collected (Databasus version, OS/arch, etc.). No DB contents, no user data. " ++ "To disable, set IS_DISABLE_ANONYMOUS_TELEMETRY=true in your .env",+ )}func runBackgroundTasks(log *slog.Logger) {@@ -329,6 +350,10 @@ func runBackgroundTasks(log *slog.Logger) {billing.GetBillingService().Run(ctx, *log)})}++ go runWithPanicLogging(log, "telemetry background service", func() {+ telemetry.GetTelemetryBackgroundService().Run(ctx)+ })} else {log.Info("Skipping primary node tasks as not primary node")}diff --git a/backend/internal/config/config.go b/backend/internal/config/config.goindex bca600eb..549a7106 100644--- a/backend/internal/config/config.go+++ b/backend/internal/config/config.go@@ -50,9 +50,12 @@ type EnvVariables struct {IsProcessingNode bool `env:"IS_PROCESSING_NODE"`NodeNetworkThroughputMBs int `env:"NODE_NETWORK_THROUGHPUT_MBPS"`- DataFolder string- TempFolder string- SecretKeyPath string+ DataFolder string+ TempFolder string+ SecretKeyPath string+ TelemetryInstancePath string++ IsDisableAnonymousTelemetry bool `env:"IS_DISABLE_ANONYMOUS_TELEMETRY"`// Billing (always tax-exclusive)PricePerGBCents int64 `env:"PRICE_PER_GB_CENTS"`@@ -325,6 +328,9 @@ func loadEnvVariables() {env.DataFolder = filepath.Join(filepath.Dir(backendRoot), "databasus-data", "backups")env.TempFolder = filepath.Join(filepath.Dir(backendRoot), "databasus-data", "temp")env.SecretKeyPath = filepath.Join(filepath.Dir(backendRoot), "databasus-data", "secret.key")+ env.TelemetryInstancePath = filepath.Join(+ filepath.Dir(backendRoot), "databasus-data", "instance.json",+ )if env.IsTesting {if env.TestPostgres12Port == "" {diff --git a/backend/internal/features/backups/backups/core/repository.go b/backend/internal/features/backups/backups/core/repository.goindex 9ef2db8f..80e7756e 100644--- a/backend/internal/features/backups/backups/core/repository.go+++ b/backend/internal/features/backups/backups/core/repository.go@@ -30,6 +30,25 @@ func (r *BackupRepository) Save(backup *Backup) error {Error}+func (r *BackupRepository) ExistsCompletedSince(+ databaseID uuid.UUID,+ since time.Time,+) (bool, error) {+ var count int64++ if err := storage.+ GetDb().+ Model(&Backup{}).+ Where("database_id = ? AND status = ? AND created_at >= ?",+ databaseID, BackupStatusCompleted, since).+ Limit(1).+ Count(&count).Error; err != nil {+ return false, err+ }++ return count > 0, nil+}+func (r *BackupRepository) FindByDatabaseID(databaseID uuid.UUID) ([]*Backup, error) {var backups []*Backupdiff --git a/backend/internal/features/backups/backups/services/service.go b/backend/internal/features/backups/backups/services/service.goindex 63a8a5f4..f9be00d6 100644--- a/backend/internal/features/backups/backups/services/service.go+++ b/backend/internal/features/backups/backups/services/service.go@@ -6,6 +6,7 @@ import ("fmt""io""log/slog"+ "time""github.com/google/uuid"@@ -55,6 +56,13 @@ func (s *BackupService) AddBackupRemoveListener(listener backups_core.BackupRemos.backupRemoveListeners = append(s.backupRemoveListeners, listener)}+func (s *BackupService) HasSuccessfulBackupSince(+ databaseID uuid.UUID,+ since time.Time,+) (bool, error) {+ return s.backupRepository.ExistsCompletedSince(databaseID, since)+}+func (s *BackupService) OnBeforeBackupsStorageChange(databaseID uuid.UUID) error {err := s.deleteDbBackups(databaseID)if err != nil {diff --git a/backend/internal/features/notifiers/repository.go b/backend/internal/features/notifiers/repository.goindex 50361b22..4a4df741 100644--- a/backend/internal/features/notifiers/repository.go+++ b/backend/internal/features/notifiers/repository.go@@ -141,6 +141,16 @@ func (r *NotifierRepository) FindByID(id uuid.UUID) (*Notifier, error) {return ¬ifier, nil}+func (r *NotifierRepository) GetAllNotifiers() ([]*Notifier, error) {+ var notifiers []*Notifier++ if err := storage.GetDb().Find(¬ifiers).Error; err != nil {+ return nil, err+ }++ return notifiers, nil+}+func (r *NotifierRepository) FindByWorkspaceID(workspaceID uuid.UUID) ([]*Notifier, error) {var notifiers []*Notifierdiff --git a/backend/internal/features/notifiers/service.go b/backend/internal/features/notifiers/service.goindex c01a50eb..c27d2436 100644--- a/backend/internal/features/notifiers/service.go+++ b/backend/internal/features/notifiers/service.go@@ -178,6 +178,10 @@ func (s *NotifierService) GetNotifierByID(id uuid.UUID) (*Notifier, error) {return s.notifierRepository.FindByID(id)}+func (s *NotifierService) GetAllNotifiers() ([]*Notifier, error) {+ return s.notifierRepository.GetAllNotifiers()+}+func (s *NotifierService) GetNotifiers(user *users_models.User,workspaceID uuid.UUID,diff --git a/backend/internal/features/storages/repository.go b/backend/internal/features/storages/repository.goindex a042cb56..b7584511 100644--- a/backend/internal/features/storages/repository.go+++ b/backend/internal/features/storages/repository.go@@ -151,6 +151,16 @@ func (r *StorageRepository) FindByID(id uuid.UUID) (*Storage, error) {return &s, nil}+func (r *StorageRepository) GetAllStorages() ([]*Storage, error) {+ var storages []*Storage++ if err := db.GetDb().Find(&storages).Error; err != nil {+ return nil, err+ }++ return storages, nil+}+func (r *StorageRepository) FindByWorkspaceID(workspaceID uuid.UUID) ([]*Storage, error) {var storages []*Storagediff --git a/backend/internal/features/storages/service.go b/backend/internal/features/storages/service.goindex eb567b88..104eb9f6 100644--- a/backend/internal/features/storages/service.go+++ b/backend/internal/features/storages/service.go@@ -320,6 +320,10 @@ func (s *StorageService) GetStorageByID(return s.storageRepository.FindByID(id)}+func (s *StorageService) GetAllStorages() ([]*Storage, error) {+ return s.storageRepository.GetAllStorages()+}+func (s *StorageService) TransferStorageToWorkspace(user *users_models.User,storageID uuid.UUID,diff --git a/backend/internal/features/system/version/controller.go b/backend/internal/features/system/version/controller.goindex f35a7d76..6a951c1f 100644--- a/backend/internal/features/system/version/controller.go+++ b/backend/internal/features/system/version/controller.go@@ -7,6 +7,8 @@ import ("github.com/gin-gonic/gin")+const defaultVersion = "3.26.0"+type VersionController struct{}func (c *VersionController) RegisterRoutes(router *gin.RouterGroup) {@@ -21,10 +23,16 @@ func (c *VersionController) RegisterRoutes(router *gin.RouterGroup) {// @Success 200 {object} VersionResponse// @Router /system/version [get]func (c *VersionController) GetVersion(ctx *gin.Context) {+ ctx.JSON(http.StatusOK, VersionResponse{Version: GetAppVersion()})+}++// GetAppVersion returns the current application version, falling back to a+// hardcoded default when APP_VERSION is unset.+func GetAppVersion() string {version := os.Getenv("APP_VERSION")if version == "" {- version = "3.26.0"+ return defaultVersion}- ctx.JSON(http.StatusOK, VersionResponse{Version: version})+ return version}diff --git a/backend/internal/features/telemetry/background_service.go b/backend/internal/features/telemetry/background_service.gonew file mode 100644index 00000000..8927074d--- /dev/null+++ b/backend/internal/features/telemetry/background_service.go@@ -0,0 +1,109 @@+package telemetry++import (+ "context"+ "fmt"+ "log/slog"+ "math/rand/v2"+ "sync/atomic"+ "time"++ "databasus-backend/internal/config"+)++const (+ defaultWarmupDuration = 1 * time.Minute+ defaultSuccessInterval = 24 * time.Hour+ defaultJitter = 10 * time.Minute+ defaultInitialBackoff = 1 * time.Minute+ defaultMaxBackoff = 24 * time.Hour+)++type TelemetryBackgroundService struct {+ telemetryService *TelemetryService+ logger *slog.Logger++ WarmupDuration time.Duration+ SuccessInterval time.Duration+ Jitter time.Duration+ InitialBackoff time.Duration+ MaxBackoff time.Duration++ hasRun atomic.Bool+}++func NewTelemetryBackgroundService(+ telemetryService *TelemetryService,+ logger *slog.Logger,+) *TelemetryBackgroundService {+ return &TelemetryBackgroundService{+ telemetryService: telemetryService,+ logger: logger,+ WarmupDuration: defaultWarmupDuration,+ SuccessInterval: defaultSuccessInterval,+ Jitter: defaultJitter,+ InitialBackoff: defaultInitialBackoff,+ MaxBackoff: defaultMaxBackoff,+ }+}++func (s *TelemetryBackgroundService) Run(ctx context.Context) {+ if s.hasRun.Swap(true) {+ panic(fmt.Sprintf("%T.Run() called multiple times", s))+ }++ if config.GetEnv().IsDisableAnonymousTelemetry {+ s.logger.Info("anonymous telemetry is disabled")+ return+ }++ if !sleep(ctx, s.WarmupDuration) {+ return+ }++ backoff := s.InitialBackoff++ for {+ err := s.telemetryService.BuildAndSend(ctx)++ var nextDelay time.Duration+ if err != nil {+ s.logger.Warn("telemetry ping failed", "error", err, "next_retry", backoff)+ nextDelay = backoff+ backoff = min(backoff*2, s.MaxBackoff)+ } else {+ backoff = s.InitialBackoff+ nextDelay = s.SuccessInterval + jitter(s.Jitter)+ }++ if !sleep(ctx, nextDelay) {+ return+ }+ }+}++// sleep returns false when ctx is cancelled before d elapses.+func sleep(ctx context.Context, d time.Duration) bool {+ if d <= 0 {+ return ctx.Err() == nil+ }++ timer := time.NewTimer(d)+ defer timer.Stop()++ select {+ case <-ctx.Done():+ return false+ case <-timer.C:+ return true+ }+}++// jitter returns a random offset in [-d, +d]. With d == 0 it returns 0.+func jitter(d time.Duration) time.Duration {+ if d <= 0 {+ return 0+ }++ return time.Duration(rand.Int64N(int64(2*d))) - d+}diff --git a/backend/internal/features/telemetry/background_service_test.go b/backend/internal/features/telemetry/background_service_test.gonew file mode 100644index 00000000..41e15286--- /dev/null+++ b/backend/internal/features/telemetry/background_service_test.go@@ -0,0 +1,199 @@+package telemetry++import (+ "context"+ "errors"+ "log/slog"+ "path/filepath"+ "sync/atomic"+ "testing"+ "time"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"++ "databasus-backend/internal/config"+)++type sequenceSender struct {+ results []error+ calls atomic.Int32+ done chan struct{}+ doneAt int32+}++func (s *sequenceSender) Send(_ context.Context, _ *CollectRequest) error {+ idx := s.calls.Add(1) - 1++ var err error+ if int(idx) < len(s.results) {+ err = s.results[int(idx)]+ }++ if s.done != nil && idx+1 == s.doneAt {+ close(s.done)+ }++ return err+}++func newBackgroundServiceUnderTest(t *testing.T, sender TelemetrySender) *TelemetryBackgroundService {+ t.Helper()++ loader := NewInstanceFileLoader(+ filepath.Join(t.TempDir(), "instance.json"),+ slog.New(slog.DiscardHandler),+ )++ service := NewTelemetryService(+ loader,+ sender,+ &fakeDatabaseLister{},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{},+ "9.9.9",+ slog.New(slog.DiscardHandler),+ )++ bg := NewTelemetryBackgroundService(service, slog.New(slog.DiscardHandler))+ // Compress all timings so tests run in milliseconds.+ bg.WarmupDuration = 5 * time.Millisecond+ bg.SuccessInterval = 20 * time.Millisecond+ bg.Jitter = 0+ bg.InitialBackoff = 5 * time.Millisecond+ bg.MaxBackoff = 40 * time.Millisecond+ return bg+}++func Test_Run_WhenDisabled_ReturnsImmediately(t *testing.T) {+ original := config.GetEnv().IsDisableAnonymousTelemetry+ config.GetEnv().IsDisableAnonymousTelemetry = true+ t.Cleanup(func() {+ config.GetEnv().IsDisableAnonymousTelemetry = original+ })++ sender := &sequenceSender{}+ bg := newBackgroundServiceUnderTest(t, sender)++ finished := make(chan struct{})+ go func() {+ bg.Run(context.Background())+ close(finished)+ }()++ select {+ case <-finished:+ case <-time.After(time.Second):+ t.Fatal("Run did not return when telemetry is disabled")+ }++ assert.Equal(t, int32(0), sender.calls.Load())+}++func Test_Run_WhenContextCancelledDuringWarmup_ReturnsCleanly(t *testing.T) {+ sender := &sequenceSender{}+ bg := newBackgroundServiceUnderTest(t, sender)+ bg.WarmupDuration = 5 * time.Second++ ctx, cancel := context.WithCancel(context.Background())+ finished := make(chan struct{})+ go func() {+ bg.Run(ctx)+ close(finished)+ }()++ cancel()++ select {+ case <-finished:+ case <-time.After(time.Second):+ t.Fatal("Run did not return after context cancellation")+ }++ assert.Equal(t, int32(0), sender.calls.Load())+}++func Test_Run_OnFailure_RetriesWithExponentialBackoff(t *testing.T) {+ done := make(chan struct{})+ sender := &sequenceSender{+ results: []error{+ errors.New("err1"),+ errors.New("err2"),+ errors.New("err3"),+ },+ done: done,+ doneAt: 3,+ }+ bg := newBackgroundServiceUnderTest(t, sender)++ ctx, cancel := context.WithCancel(context.Background())+ finished := make(chan struct{})+ go func() {+ bg.Run(ctx)+ close(finished)+ }()++ select {+ case <-done:+ case <-time.After(2 * time.Second):+ t.Fatal("did not see three retries within timeout")+ }++ cancel()+ <-finished++ assert.GreaterOrEqual(t, sender.calls.Load(), int32(3))+}++func Test_Run_OnSuccessAfterFailure_ResetsBackoffAndContinues(t *testing.T) {+ done := make(chan struct{})+ sender := &sequenceSender{+ results: []error{errors.New("transient"), nil, nil},+ done: done,+ doneAt: 3,+ }+ bg := newBackgroundServiceUnderTest(t, sender)++ ctx, cancel := context.WithCancel(context.Background())+ finished := make(chan struct{})+ go func() {+ bg.Run(ctx)+ close(finished)+ }()++ select {+ case <-done:+ case <-time.After(2 * time.Second):+ t.Fatal("did not see recovery within timeout")+ }++ cancel()+ <-finished++ assert.GreaterOrEqual(t, sender.calls.Load(), int32(3))+}++func Test_Run_WhenCalledTwice_Panics(t *testing.T) {+ sender := &sequenceSender{}+ bg := newBackgroundServiceUnderTest(t, sender)++ ctx, cancel := context.WithCancel(context.Background())+ defer cancel()++ finished := make(chan struct{})+ go func() {+ bg.Run(ctx)+ close(finished)+ }()++ // Wait long enough to be sure the first Run has flipped hasRun to true.+ time.Sleep(10 * time.Millisecond)++ require.Panics(t, func() {+ bg.Run(ctx)+ })++ cancel()+ <-finished+}diff --git a/backend/internal/features/telemetry/client.go b/backend/internal/features/telemetry/client.gonew file mode 100644index 00000000..523c68c5--- /dev/null+++ b/backend/internal/features/telemetry/client.go@@ -0,0 +1,60 @@+package telemetry++import (+ "bytes"+ "context"+ "encoding/json"+ "fmt"+ "io"+ "net/http"+ "time"+)++type TelemetrySender interface {+ Send(ctx context.Context, req *CollectRequest) error+}++type HTTPTelemetrySender struct {+ endpoint string+ appVersion string+ httpClient *http.Client+}++func NewHTTPTelemetrySender(endpoint, appVersion string) *HTTPTelemetrySender {+ return &HTTPTelemetrySender{+ endpoint: endpoint,+ appVersion: appVersion,+ httpClient: &http.Client{Timeout: 5 * time.Second},+ }+}++func (s *HTTPTelemetrySender) Send(ctx context.Context, req *CollectRequest) error {+ body, err := json.Marshal(req)+ if err != nil {+ return fmt.Errorf("failed to encode telemetry request: %w", err)+ }++ httpReq, err := http.NewRequestWithContext(+ ctx, http.MethodPost, s.endpoint, bytes.NewReader(body),+ )+ if err != nil {+ return fmt.Errorf("failed to build telemetry request: %w", err)+ }++ httpReq.Header.Set("Content-Type", "application/json")+ httpReq.Header.Set("User-Agent", "Postgresus-Telemetry/"+s.appVersion)++ resp, err := s.httpClient.Do(httpReq)+ if err != nil {+ return fmt.Errorf("telemetry request failed: %w", err)+ }+ defer func() { _ = resp.Body.Close() }()++ if resp.StatusCode < 200 || resp.StatusCode >= 300 {+ // Drain a small slice so the connection can be reused.+ respBody, _ := io.ReadAll(io.LimitReader(resp.Body, 512))+ return fmt.Errorf("telemetry endpoint returned %d: %s", resp.StatusCode, string(respBody))+ }++ return nil+}diff --git a/backend/internal/features/telemetry/client_test.go b/backend/internal/features/telemetry/client_test.gonew file mode 100644index 00000000..f619efee--- /dev/null+++ b/backend/internal/features/telemetry/client_test.go@@ -0,0 +1,85 @@+package telemetry++import (+ "context"+ "encoding/json"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "testing"++ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func Test_Send_PostsCorrectBodyAndHeaders(t *testing.T) {+ var captured CollectRequest+ var captureMethod string+ var captureContentType string+ var captureUserAgent string++ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ captureMethod = r.Method+ captureContentType = r.Header.Get("Content-Type")+ captureUserAgent = r.Header.Get("User-Agent")++ body, err := io.ReadAll(r.Body)+ require.NoError(t, err)+ require.NoError(t, json.Unmarshal(body, &captured))++ w.WriteHeader(http.StatusAccepted)+ _, _ = w.Write([]byte(`{"status":"accepted"}`))+ }))+ defer server.Close()++ sender := NewHTTPTelemetrySender(server.URL, "9.9.9")+ req := &CollectRequest{+ InstanceID: "550e8400-e29b-41d4-a716-446655440000",+ AppVersion: "9.9.9",+ OS: "linux",+ Arch: "amd64",+ InstalledAt: "2026-04-29",+ Databases: []DatabaseEntry{{Type: "POSTGRES", Version: "16"}},+ Storages: []string{"S3"},+ Notifiers: []string{"EMAIL"},+ }++ require.NoError(t, sender.Send(context.Background(), req))++ assert.Equal(t, http.MethodPost, captureMethod)+ assert.Equal(t, "application/json", captureContentType)+ assert.True(t, strings.HasPrefix(captureUserAgent, "Postgresus-Telemetry/"))+ assert.Contains(t, captureUserAgent, "9.9.9")+ assert.Equal(t, *req, captured)+}++func Test_Send_WhenServerReturns202_ReturnsNil(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusAccepted)+ }))+ defer server.Close()++ sender := NewHTTPTelemetrySender(server.URL, "1.0.0")+ assert.NoError(t, sender.Send(context.Background(), &CollectRequest{}))+}++func Test_Send_WhenServerReturns500_ReturnsError(t *testing.T) {+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {+ w.WriteHeader(http.StatusInternalServerError)+ _, _ = w.Write([]byte(`{"error":"boom"}`))+ }))+ defer server.Close()++ sender := NewHTTPTelemetrySender(server.URL, "1.0.0")+ err := sender.Send(context.Background(), &CollectRequest{})++ require.Error(t, err)+ assert.Contains(t, err.Error(), "500")+}++func Test_Send_WhenEndpointUnreachable_ReturnsError(t *testing.T) {+ sender := NewHTTPTelemetrySender("http://127.0.0.1:1/never", "1.0.0")+ err := sender.Send(context.Background(), &CollectRequest{})+ require.Error(t, err)+}diff --git a/backend/internal/features/telemetry/di.go b/backend/internal/features/telemetry/di.gonew file mode 100644index 00000000..a5884874--- /dev/null+++ b/backend/internal/features/telemetry/di.go@@ -0,0 +1,50 @@+package telemetry++import (+ "sync"++ "databasus-backend/internal/config"+ backups_services "databasus-backend/internal/features/backups/backups/services"+ "databasus-backend/internal/features/databases"+ "databasus-backend/internal/features/notifiers"+ "databasus-backend/internal/features/storages"+ system_version "databasus-backend/internal/features/system/version"+ "databasus-backend/internal/util/logger"+)++const productionEndpoint = "https://metrics.databasus.com/api/anonymous/collect"++var (+ telemetryLogger = logger.GetLogger()++ instanceLoader = NewInstanceFileLoader("", telemetryLogger)+ httpSender = NewHTTPTelemetrySender(productionEndpoint, system_version.GetAppVersion())++ telemetryService = NewTelemetryService(+ instanceLoader,+ httpSender,+ databases.GetDatabaseService(),+ storages.GetStorageService(),+ notifiers.GetNotifierService(),+ backups_services.GetBackupService(),+ system_version.GetAppVersion(),+ telemetryLogger,+ )++ telemetryBackgroundService = NewTelemetryBackgroundService(+ telemetryService,+ telemetryLogger,+ )+)++func GetTelemetryService() *TelemetryService {+ return telemetryService+}++func GetTelemetryBackgroundService() *TelemetryBackgroundService {+ return telemetryBackgroundService+}++var SetupDependencies = sync.OnceFunc(func() {+ instanceLoader.path = config.GetEnv().TelemetryInstancePath+})diff --git a/backend/internal/features/telemetry/dto.go b/backend/internal/features/telemetry/dto.gonew file mode 100644index 00000000..47e0ac47--- /dev/null+++ b/backend/internal/features/telemetry/dto.go@@ -0,0 +1,17 @@+package telemetry++type DatabaseEntry struct {+ Type string `json:"type"`+ Version string `json:"version"`+}++type CollectRequest struct {+ InstanceID string `json:"instanceID"`+ AppVersion string `json:"appVersion"`+ OS string `json:"os"`+ Arch string `json:"arch"`+ InstalledAt string `json:"installedAt,omitempty"`+ Databases []DatabaseEntry `json:"databases"`+ Storages []string `json:"storages"`+ Notifiers []string `json:"notifiers"`+}diff --git a/backend/internal/features/telemetry/instance_file.go b/backend/internal/features/telemetry/instance_file.gonew file mode 100644index 00000000..d6494d9b--- /dev/null+++ b/backend/internal/features/telemetry/instance_file.go@@ -0,0 +1,82 @@+package telemetry++import (+ "encoding/json"+ "log/slog"+ "os"+ "path/filepath"+ "time"++ "github.com/google/uuid"+)++type Instance struct {+ InstanceID string `json:"instanceID"`+ InstalledAt string `json:"installedAt"`+}++type InstanceFileLoader struct {+ path string+ logger *slog.Logger+}++func NewInstanceFileLoader(path string, logger *slog.Logger) *InstanceFileLoader {+ return &InstanceFileLoader{path: path, logger: logger}+}++// LoadOrCreate returns (instance, true) on success and (nil, false) when the+// file cannot be read or written. Telemetry is skipped on failure rather than+// falling back to an ephemeral UUID — phantom new instances on every restart+// would pollute the central counts.+func (l *InstanceFileLoader) LoadOrCreate() (*Instance, bool) {+ data, err := os.ReadFile(l.path)+ if err == nil {+ var instance Instance++ if err := json.Unmarshal(data, &instance); err != nil {+ l.logger.Warn("telemetry instance file is corrupt; skipping telemetry",+ "path", l.path, "error", err)+ return nil, false+ }++ if instance.InstanceID == "" {+ l.logger.Warn("telemetry instance file is missing instanceID; skipping telemetry",+ "path", l.path)+ return nil, false+ }++ return &instance, true+ }++ if !os.IsNotExist(err) {+ l.logger.Warn("failed to read telemetry instance file; skipping telemetry",+ "path", l.path, "error", err)+ return nil, false+ }++ instance := &Instance{+ InstanceID: uuid.New().String(),+ InstalledAt: time.Now().UTC().Format("2006-01-02"),+ }++ encoded, err := json.Marshal(instance)+ if err != nil {+ l.logger.Warn("failed to encode telemetry instance file; skipping telemetry",+ "path", l.path, "error", err)+ return nil, false+ }++ if err := os.MkdirAll(filepath.Dir(l.path), 0o700); err != nil {+ l.logger.Warn("failed to create telemetry instance file directory; skipping telemetry",+ "path", l.path, "error", err)+ return nil, false+ }++ if err := os.WriteFile(l.path, encoded, 0o600); err != nil {+ l.logger.Warn("failed to write telemetry instance file; skipping telemetry",+ "path", l.path, "error", err)+ return nil, false+ }++ return instance, true+}diff --git a/backend/internal/features/telemetry/instance_file_test.go b/backend/internal/features/telemetry/instance_file_test.gonew file mode 100644index 00000000..106d8708--- /dev/null+++ b/backend/internal/features/telemetry/instance_file_test.go@@ -0,0 +1,91 @@+package telemetry++import (+ "encoding/json"+ "log/slog"+ "os"+ "path/filepath"+ "testing"+ "time"++ "github.com/google/uuid"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"+)++func newTestLoader(t *testing.T) (*InstanceFileLoader, string) {+ t.Helper()+ dir := t.TempDir()+ path := filepath.Join(dir, "instance.json")++ return NewInstanceFileLoader(path, slog.New(slog.DiscardHandler)), path+}++func Test_LoadOrCreate_WhenFileMissing_CreatesNewWithUUIDAndToday(t *testing.T) {+ loader, path := newTestLoader(t)++ instance, ok := loader.LoadOrCreate()+ require.True(t, ok)+ require.NotNil(t, instance)++ _, err := uuid.Parse(instance.InstanceID)+ require.NoError(t, err, "instance id should be a valid UUID")++ assert.Equal(t, time.Now().UTC().Format("2006-01-02"), instance.InstalledAt)++ data, err := os.ReadFile(path)+ require.NoError(t, err)++ var persisted Instance+ require.NoError(t, json.Unmarshal(data, &persisted))+ assert.Equal(t, instance.InstanceID, persisted.InstanceID)+ assert.Equal(t, instance.InstalledAt, persisted.InstalledAt)+}++func Test_LoadOrCreate_WhenFileExists_ReturnsExisting(t *testing.T) {+ loader, _ := newTestLoader(t)++ first, ok := loader.LoadOrCreate()+ require.True(t, ok)++ second, ok := loader.LoadOrCreate()+ require.True(t, ok)++ assert.Equal(t, first.InstanceID, second.InstanceID)+ assert.Equal(t, first.InstalledAt, second.InstalledAt)+}++func Test_LoadOrCreate_WhenFileCorrupt_ReturnsFalse(t *testing.T) {+ loader, path := newTestLoader(t)++ require.NoError(t, os.WriteFile(path, []byte("not-json"), 0o600))++ instance, ok := loader.LoadOrCreate()+ assert.False(t, ok)+ assert.Nil(t, instance)+}++func Test_LoadOrCreate_WhenFileEmpty_ReturnsFalse(t *testing.T) {+ loader, path := newTestLoader(t)++ require.NoError(t, os.WriteFile(path, []byte("{}"), 0o600))++ instance, ok := loader.LoadOrCreate()+ assert.False(t, ok)+ assert.Nil(t, instance)+}++func Test_LoadOrCreate_WhenDirectoryUnwritable_ReturnsFalse(t *testing.T) {+ dir := t.TempDir()+ // Point at a path whose parent is a regular file — making the+ // MkdirAll/WriteFile sequence impossible regardless of OS permissions.+ blocker := filepath.Join(dir, "blocker")+ require.NoError(t, os.WriteFile(blocker, []byte("x"), 0o600))++ path := filepath.Join(blocker, "nested", "instance.json")+ loader := NewInstanceFileLoader(path, slog.New(slog.DiscardHandler))++ instance, ok := loader.LoadOrCreate()+ assert.False(t, ok)+ assert.Nil(t, instance)+}diff --git a/backend/internal/features/telemetry/service.go b/backend/internal/features/telemetry/service.gonew file mode 100644index 00000000..0778db5f--- /dev/null+++ b/backend/internal/features/telemetry/service.go@@ -0,0 +1,252 @@+package telemetry++import (+ "context"+ "log/slog"+ "runtime"+ "sort"+ "time"++ "github.com/google/uuid"++ "databasus-backend/internal/features/databases"+ "databasus-backend/internal/features/notifiers"+ "databasus-backend/internal/features/storages"+)++const (+ // activeBackupWindow is how far back a successful backup must have happened+ // for a database with disabled healthcheck to count as "active".+ activeBackupWindow = 7 * 24 * time.Hour++ // maxArrayEntries matches the server-side cap from TELEMETRY.md.+ maxArrayEntries = 200+)++type databaseLister interface {+ GetAllDatabases() ([]*databases.Database, error)+}++type storageLister interface {+ GetAllStorages() ([]*storages.Storage, error)+}++type notifierLister interface {+ GetAllNotifiers() ([]*notifiers.Notifier, error)+}++type backupChecker interface {+ HasSuccessfulBackupSince(databaseID uuid.UUID, since time.Time) (bool, error)+}++type TelemetryService struct {+ instanceLoader *InstanceFileLoader+ sender TelemetrySender+ databaseService databaseLister+ storageService storageLister+ notifierService notifierLister+ backupService backupChecker+ appVersion string+ logger *slog.Logger+}++func NewTelemetryService(+ instanceLoader *InstanceFileLoader,+ sender TelemetrySender,+ databaseService databaseLister,+ storageService storageLister,+ notifierService notifierLister,+ backupService backupChecker,+ appVersion string,+ logger *slog.Logger,+) *TelemetryService {+ return &TelemetryService{+ instanceLoader: instanceLoader,+ sender: sender,+ databaseService: databaseService,+ storageService: storageService,+ notifierService: notifierService,+ backupService: backupService,+ appVersion: appVersion,+ logger: logger,+ }+}++func (s *TelemetryService) BuildAndSend(ctx context.Context) error {+ instance, ok := s.instanceLoader.LoadOrCreate()+ if !ok {+ return nil+ }++ databaseEntries, err := s.collectActiveDatabases()+ if err != nil {+ return err+ }++ storageTypes, err := s.collectStorageTypes()+ if err != nil {+ return err+ }++ notifierTypes, err := s.collectNotifierTypes()+ if err != nil {+ return err+ }++ req := &CollectRequest{+ InstanceID: instance.InstanceID,+ AppVersion: s.appVersion,+ OS: runtime.GOOS,+ Arch: runtime.GOARCH,+ InstalledAt: instance.InstalledAt,+ Databases: capDatabases(databaseEntries),+ Storages: capStrings(storageTypes),+ Notifiers: capStrings(notifierTypes),+ }++ return s.sender.Send(ctx, req)+}++func (s *TelemetryService) collectActiveDatabases() ([]DatabaseEntry, error) {+ allDatabases, err := s.databaseService.GetAllDatabases()+ if err != nil {+ return nil, err+ }++ since := time.Now().UTC().Add(-activeBackupWindow)+ entries := make([]DatabaseEntry, 0, len(allDatabases))++ for _, db := range allDatabases {+ isActive, err := s.isDatabaseActive(db, since)+ if err != nil {+ return nil, err+ }++ if !isActive {+ continue+ }++ entry, ok := buildDatabaseEntry(db)+ if !ok {+ continue+ }++ entries = append(entries, entry)+ }++ return entries, nil+}++// isDatabaseActive returns true when a database should be counted in telemetry.+//+// - HealthStatus == AVAILABLE → active.+// - HealthStatus == UNAVAILABLE → not active (healthcheck is on and the DB is down).+// - HealthStatus == nil → healthcheck is disabled; active only if a+// successful backup happened inside `since`.+func (s *TelemetryService) isDatabaseActive(+ db *databases.Database,+ since time.Time,+) (bool, error) {+ if db.HealthStatus != nil {+ return *db.HealthStatus == databases.HealthStatusAvailable, nil+ }++ return s.backupService.HasSuccessfulBackupSince(db.ID, since)+}++func buildDatabaseEntry(db *databases.Database) (DatabaseEntry, bool) {+ switch db.Type {+ case databases.DatabaseTypePostgres:+ if db.Postgresql == nil {+ return DatabaseEntry{}, false+ }+ return DatabaseEntry{Type: string(db.Type), Version: string(db.Postgresql.Version)}, true+ case databases.DatabaseTypeMysql:+ if db.Mysql == nil {+ return DatabaseEntry{}, false+ }+ return DatabaseEntry{Type: string(db.Type), Version: string(db.Mysql.Version)}, true+ case databases.DatabaseTypeMariadb:+ if db.Mariadb == nil {+ return DatabaseEntry{}, false+ }+ return DatabaseEntry{Type: string(db.Type), Version: string(db.Mariadb.Version)}, true+ case databases.DatabaseTypeMongodb:+ if db.Mongodb == nil {+ return DatabaseEntry{}, false+ }+ return DatabaseEntry{Type: string(db.Type), Version: string(db.Mongodb.Version)}, true+ }++ return DatabaseEntry{}, false+}++func (s *TelemetryService) collectStorageTypes() ([]string, error) {+ allStorages, err := s.storageService.GetAllStorages()+ if err != nil {+ return nil, err+ }++ seen := make(map[string]struct{}, len(allStorages))+ types := make([]string, 0, len(allStorages))++ for _, st := range allStorages {+ key := string(st.Type)+ if key == "" {+ continue+ }++ if _, exists := seen[key]; exists {+ continue+ }++ seen[key] = struct{}{}+ types = append(types, key)+ }++ sort.Strings(types)+ return types, nil+}++func (s *TelemetryService) collectNotifierTypes() ([]string, error) {+ allNotifiers, err := s.notifierService.GetAllNotifiers()+ if err != nil {+ return nil, err+ }++ seen := make(map[string]struct{}, len(allNotifiers))+ types := make([]string, 0, len(allNotifiers))++ for _, n := range allNotifiers {+ key := string(n.NotifierType)+ if key == "" {+ continue+ }++ if _, exists := seen[key]; exists {+ continue+ }++ seen[key] = struct{}{}+ types = append(types, key)+ }++ sort.Strings(types)+ return types, nil+}++func capStrings(in []string) []string {+ if len(in) > maxArrayEntries {+ return in[:maxArrayEntries]+ }++ return in+}++func capDatabases(in []DatabaseEntry) []DatabaseEntry {+ if len(in) > maxArrayEntries {+ return in[:maxArrayEntries]+ }++ return in+}diff --git a/backend/internal/features/telemetry/service_test.go b/backend/internal/features/telemetry/service_test.gonew file mode 100644index 00000000..4add9cbd--- /dev/null+++ b/backend/internal/features/telemetry/service_test.go@@ -0,0 +1,359 @@+package telemetry++import (+ "context"+ "errors"+ "log/slog"+ "os"+ "path/filepath"+ "runtime"+ "testing"+ "time"++ "github.com/google/uuid"+ "github.com/stretchr/testify/assert"+ "github.com/stretchr/testify/require"++ "databasus-backend/internal/features/databases"+ "databasus-backend/internal/features/databases/databases/mariadb"+ "databasus-backend/internal/features/databases/databases/mongodb"+ "databasus-backend/internal/features/databases/databases/mysql"+ "databasus-backend/internal/features/databases/databases/postgresql"+ "databasus-backend/internal/features/notifiers"+ "databasus-backend/internal/features/storages"+ "databasus-backend/internal/util/tools"+)++type fakeSender struct {+ calls []*CollectRequest+ err error+}++func (f *fakeSender) Send(_ context.Context, req *CollectRequest) error {+ f.calls = append(f.calls, req)+ return f.err+}++type fakeDatabaseLister struct {+ databases []*databases.Database+ err error+}++func (f *fakeDatabaseLister) GetAllDatabases() ([]*databases.Database, error) {+ return f.databases, f.err+}++type fakeStorageLister struct {+ storages []*storages.Storage+ err error+}++func (f *fakeStorageLister) GetAllStorages() ([]*storages.Storage, error) {+ return f.storages, f.err+}++type fakeNotifierLister struct {+ notifiers []*notifiers.Notifier+ err error+}++func (f *fakeNotifierLister) GetAllNotifiers() ([]*notifiers.Notifier, error) {+ return f.notifiers, f.err+}++type fakeBackupChecker struct {+ hasBackupSince map[uuid.UUID]bool+ err error+}++func (f *fakeBackupChecker) HasSuccessfulBackupSince(+ databaseID uuid.UUID,+ _ time.Time,+) (bool, error) {+ if f.err != nil {+ return false, f.err+ }++ return f.hasBackupSince[databaseID], nil+}++func newServiceUnderTest(+ t *testing.T,+ databaseLister databaseLister,+ storageLister storageLister,+ notifierLister notifierLister,+ backupChecker backupChecker,+ sender TelemetrySender,+) *TelemetryService {+ t.Helper()+ loader := NewInstanceFileLoader(+ filepath.Join(t.TempDir(), "instance.json"),+ slog.New(slog.DiscardHandler),+ )++ return NewTelemetryService(+ loader,+ sender,+ databaseLister,+ storageLister,+ notifierLister,+ backupChecker,+ "9.9.9",+ slog.New(slog.DiscardHandler),+ )+}++func availableStatus() *databases.HealthStatus {+ s := databases.HealthStatusAvailable+ return &s+}++func unavailableStatus() *databases.HealthStatus {+ s := databases.HealthStatusUnavailable+ return &s+}++func postgresDatabase(name string, status *databases.HealthStatus) *databases.Database {+ return &databases.Database{+ ID: uuid.New(),+ Name: name,+ Type: databases.DatabaseTypePostgres,+ HealthStatus: status,+ Postgresql: &postgresql.PostgresqlDatabase{+ Version: tools.PostgresqlVersion("16"),+ },+ }+}++func Test_BuildAndSend_ProducesExpectedRequest(t *testing.T) {+ pgDB := postgresDatabase("pg", availableStatus())+ mysqlDB := &databases.Database{+ ID: uuid.New(),+ Name: "my",+ Type: databases.DatabaseTypeMysql,+ HealthStatus: availableStatus(),+ Mysql: &mysql.MysqlDatabase{Version: tools.MysqlVersion("8.0")},+ }+ mariaDB := &databases.Database{+ ID: uuid.New(),+ Name: "maria",+ Type: databases.DatabaseTypeMariadb,+ HealthStatus: availableStatus(),+ Mariadb: &mariadb.MariadbDatabase{Version: tools.MariadbVersion("10.6")},+ }+ mongoDB := &databases.Database{+ ID: uuid.New(),+ Name: "mongo",+ Type: databases.DatabaseTypeMongodb,+ HealthStatus: availableStatus(),+ Mongodb: &mongodb.MongodbDatabase{Version: tools.MongodbVersion("6.0")},+ }++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{pgDB, mysqlDB, mariaDB, mongoDB}},+ &fakeStorageLister{storages: []*storages.Storage{+ {Type: storages.StorageTypeS3},+ {Type: storages.StorageTypeLocal},+ }},+ &fakeNotifierLister{notifiers: []*notifiers.Notifier{+ {NotifierType: notifiers.NotifierTypeEmail},+ {NotifierType: notifiers.NotifierTypeTelegram},+ }},+ &fakeBackupChecker{},+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)++ req := sender.calls[0]+ assert.Equal(t, "9.9.9", req.AppVersion)+ assert.Equal(t, runtime.GOOS, req.OS)+ assert.Equal(t, runtime.GOARCH, req.Arch)+ require.Len(t, req.Databases, 4)++ types := make([]string, 0, len(req.Databases))+ for _, d := range req.Databases {+ types = append(types, d.Type)+ }+ assert.ElementsMatch(t,+ []string{"POSTGRES", "MYSQL", "MARIADB", "MONGODB"},+ types,+ )++ assert.Equal(t, []string{"LOCAL", "S3"}, req.Storages)+ assert.Equal(t, []string{"EMAIL", "TELEGRAM"}, req.Notifiers)+ assert.Equal(t, time.Now().UTC().Format("2006-01-02"), req.InstalledAt)+ _, err := uuid.Parse(req.InstanceID)+ require.NoError(t, err)+}++func Test_BuildAndSend_DedupesStoragesAndNotifiers(t *testing.T) {+ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{},+ &fakeStorageLister{storages: []*storages.Storage{+ {Type: storages.StorageTypeS3},+ {Type: storages.StorageTypeS3},+ {Type: storages.StorageTypeLocal},+ }},+ &fakeNotifierLister{notifiers: []*notifiers.Notifier{+ {NotifierType: notifiers.NotifierTypeEmail},+ {NotifierType: notifiers.NotifierTypeEmail},+ {NotifierType: notifiers.NotifierTypeTelegram},+ }},+ &fakeBackupChecker{},+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)++ assert.Equal(t, []string{"LOCAL", "S3"}, sender.calls[0].Storages)+ assert.Equal(t, []string{"EMAIL", "TELEGRAM"}, sender.calls[0].Notifiers)+}++func Test_BuildAndSend_WhenInstanceFileFails_DoesNotCallSender(t *testing.T) {+ // Construct a loader pointing at an unwritable path so LoadOrCreate returns false.+ dir := t.TempDir()+ blocker := filepath.Join(dir, "blocker")+ require.NoError(t, writeFileForTest(blocker))++ sender := &fakeSender{}+ loader := NewInstanceFileLoader(+ filepath.Join(blocker, "nested", "instance.json"),+ slog.New(slog.DiscardHandler),+ )++ service := NewTelemetryService(+ loader,+ sender,+ &fakeDatabaseLister{},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{},+ "9.9.9",+ slog.New(slog.DiscardHandler),+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ assert.Empty(t, sender.calls)+}++func Test_BuildAndSend_WhenSenderFails_PropagatesError(t *testing.T) {+ sendErr := errors.New("network down")+ sender := &fakeSender{err: sendErr}++ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{},+ sender,+ )++ err := service.BuildAndSend(context.Background())+ require.Error(t, err)+ assert.ErrorIs(t, err, sendErr)+}++func Test_BuildAndSend_WhenDbHealthStatusAvailable_DbIncluded(t *testing.T) {+ db := postgresDatabase("pg", availableStatus())++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{},+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ assert.Len(t, sender.calls[0].Databases, 1)+}++func Test_BuildAndSend_WhenDbHealthStatusUnavailable_DbExcluded(t *testing.T) {+ db := postgresDatabase("pg", unavailableStatus())++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{},+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ assert.Empty(t, sender.calls[0].Databases)+}++func Test_BuildAndSend_WhenHealthcheckOffAndRecentBackup_DbIncluded(t *testing.T) {+ db := postgresDatabase("pg", nil)++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{hasBackupSince: map[uuid.UUID]bool{db.ID: true}},+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ require.Len(t, sender.calls[0].Databases, 1)+ assert.Equal(t, "POSTGRES", sender.calls[0].Databases[0].Type)+}++func Test_BuildAndSend_WhenHealthcheckOffAndNoRecentBackup_DbExcluded(t *testing.T) {+ db := postgresDatabase("pg", nil)++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{hasBackupSince: map[uuid.UUID]bool{}},+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ assert.Empty(t, sender.calls[0].Databases)+}++func Test_BuildAndSend_WhenBackupCheckerFails_ReturnsError(t *testing.T) {+ db := postgresDatabase("pg", nil)+ checkerErr := errors.New("db down")++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{err: checkerErr},+ sender,+ )++ err := service.BuildAndSend(context.Background())+ require.Error(t, err)+ assert.ErrorIs(t, err, checkerErr)+ assert.Empty(t, sender.calls)+}++func writeFileForTest(path string) error {+ return os.WriteFile(path, []byte("x"), 0o600)+}diff --git a/frontend/src/features/backups/ui/BackupsComponent.tsx b/frontend/src/features/backups/ui/BackupsComponent.tsxindex 9693b143..87c1ea93 100644--- a/frontend/src/features/backups/ui/BackupsComponent.tsx+++ b/frontend/src/features/backups/ui/BackupsComponent.tsx@@ -569,17 +569,6 @@ export const BackupsComponent = ({<span className="md:hidden">Backup now</span><span className="hidden md:inline">Make backup right now</span></Button>-- {!IS_CLOUD && (- <a- href="https://databasus.com/cloud"- target="_blank"- rel="noreferrer"- className="inline-flex h-8 items-center rounded-md border border-blue-600 px-[15px] text-sm leading-none transition-colors hover:bg-blue-50 dark:!text-white dark:hover:bg-blue-900/30"- >- Get 24x7 uptime and 2x independent backups copy- </a>- )}</div>)}diff --git a/frontend/src/features/users/ui/AuthNavbarComponent.tsx b/frontend/src/features/users/ui/AuthNavbarComponent.tsxindex 97879187..40d5dbbf 100644--- a/frontend/src/features/users/ui/AuthNavbarComponent.tsx+++ b/frontend/src/features/users/ui/AuthNavbarComponent.tsx@@ -1,3 +1,5 @@+import { Tooltip } from 'antd';+import { IS_CLOUD } from '../../../constants';import { StarButtonComponent } from '../../../shared/ui/StarButtonComponent';import { ThemeToggleComponent } from '../../../shared/ui/ThemeToggleComponent';@@ -33,14 +35,20 @@ export function AuthNavbarComponent() {</a>{!IS_CLOUD && (- <a- className="!text-black hover:opacity-80 dark:!text-gray-200"- href="https://databasus.com/cloud"- target="_blank"- rel="noreferrer"- >- Cloud- </a>+ <Tooltip title="99.9% uptime, 2x backup copies">+ <a+ className="flex items-center gap-2 !text-black hover:opacity-80 dark:!text-gray-200"+ href="https://databasus.com/cloud"+ target="_blank"+ rel="noreferrer"+ >+ Cloud+ <span className="relative flex h-2 w-2" aria-label="99.9% uptime, 2x backup copies">+ <span className="absolute inline-flex h-full w-full animate-ping rounded-full bg-green-500 opacity-75" />+ <span className="relative inline-flex h-2 w-2 rounded-full bg-green-500" />+ </span>+ </a>+ </Tooltip>)}<div className="flex items-center gap-2">diff --git a/frontend/src/widgets/main/MainScreenComponent.tsx b/frontend/src/widgets/main/MainScreenComponent.tsxindex c561e678..6f5d0d5b 100644--- a/frontend/src/widgets/main/MainScreenComponent.tsx+++ b/frontend/src/widgets/main/MainScreenComponent.tsx@@ -231,14 +231,20 @@ export const MainScreenComponent = () => {</a>{!IS_CLOUD && (- <a- className="!text-black hover:opacity-80 dark:!text-gray-200"- href="https://databasus.com/cloud"- target="_blank"- rel="noreferrer"- >- Cloud- </a>+ <Tooltip title="99.9% uptime, 2x backup copies">+ <a+ className="flex items-center gap-2 !text-black hover:opacity-80 dark:!text-gray-200"+ href="https://databasus.com/cloud"+ target="_blank"+ rel="noreferrer"+ >+ Cloud+ <span className="relative flex h-2 w-2" aria-label="99.9% uptime, 2 backup copies">+ <span className="absolute inline-flex h-full w-full animate-ping rounded-full bg-green-500 opacity-75" />+ <span className="relative inline-flex h-2 w-2 rounded-full bg-green-500" />+ </span>+ </a>+ </Tooltip>)}{isUsedMoreThan85Percent && (