Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

FEATURE (telemetry): Add anonymous telemetry (databasus version, arch, etc.)

Rostislav Duginb9940e0d30c1
diff --git a/README.md b/README.md
index db698a00..fe55de03 100644
--- a/README.md
+++ b/README.md
@@ -302,8 +302,8 @@ We also draw attention to fast issue resolution and security [vulnerability repo
Yes. 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.go
index 6dec3421..080586a5 100644
--- a/backend/cmd/main.go
+++ b/backend/cmd/main.go
@@ -3,6 +3,7 @@ package main
import (
"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.go
index 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.go
index 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 []*Backup
diff --git a/backend/internal/features/backups/backups/services/service.go b/backend/internal/features/backups/backups/services/service.go
index 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.BackupRemo
s.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.go
index 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 &notifier, nil
}
+func (r *NotifierRepository) GetAllNotifiers() ([]*Notifier, error) {
+ var notifiers []*Notifier
+
+ if err := storage.GetDb().Find(&notifiers).Error; err != nil {
+ return nil, err
+ }
+
+ return notifiers, nil
+}
+
func (r *NotifierRepository) FindByWorkspaceID(workspaceID uuid.UUID) ([]*Notifier, error) {
var notifiers []*Notifier
diff --git a/backend/internal/features/notifiers/service.go b/backend/internal/features/notifiers/service.go
index 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.go
index 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 []*Storage
diff --git a/backend/internal/features/storages/service.go b/backend/internal/features/storages/service.go
index 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.go
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.tsx
index 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.tsx
index 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.tsx
index 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 && (