PostgreSQL backup tool with Point-In-Time-Recovery and restore verification
TypeScript backupbackupsdatabasedatabase-backupdevopsdockergolangkubernetesmariadbmongodbmysqlpgpostgrespostgresqls3self-hostedsystem-administrationtoolsweb-ui
FEATURE (backups): Add DB raw size to backup size and display on UI
Rostislav Duginee59d8dd9e6a
diff --git a/backend/internal/features/backups/backups/core/model.go b/backend/internal/features/backups/backups/core/model.goindex 8ca49fd6..89fc96ad 100644--- a/backend/internal/features/backups/backups/core/model.go+++ b/backend/internal/features/backups/backups/core/model.go@@ -28,7 +28,8 @@ type Backup struct {FailMessage *string `json:"failMessage" gorm:"column:fail_message"`IsSkipRetry bool `json:"isSkipRetry" gorm:"column:is_skip_retry;type:boolean;not null"`- BackupSizeMb float64 `json:"backupSizeMb" gorm:"column:backup_size_mb;default:0"`+ BackupSizeMb float64 `json:"backupSizeMb" gorm:"column:backup_size_mb;default:0"`+ BackupRawDbSizeMb float64 `json:"backupRawDbSizeMb" gorm:"column:backup_raw_db_size_mb;default:0"`BackupDurationMs int64 `json:"backupDurationMs" gorm:"column:backup_duration_ms;default:0"`diff --git a/backend/internal/features/backups/backups/core/repository.go b/backend/internal/features/backups/backups/core/repository.goindex 80e7756e..5a0b1693 100644--- a/backend/internal/features/backups/backups/core/repository.go+++ b/backend/internal/features/backups/backups/core/repository.go@@ -316,6 +316,28 @@ func (r *BackupRepository) FindCompletedWalSegmentsAfter(return backups, nil}+func (r *BackupRepository) FindLatestCompleted(+ databaseID uuid.UUID,+) (*Backup, error) {+ var backup Backup++ err := storage.+ GetDb().+ Where("database_id = ? AND status = ?",+ databaseID, BackupStatusCompleted).+ Order("created_at DESC").+ First(&backup).Error+ if err != nil {+ if errors.Is(err, gorm.ErrRecordNotFound) {+ return nil, nil+ }++ return nil, err+ }++ return &backup, nil+}+func (r *BackupRepository) FindLastCompletedFullWalBackupByDatabaseID(databaseID uuid.UUID,) (*Backup, error) {diff --git a/backend/internal/features/backups/backups/services/service.go b/backend/internal/features/backups/backups/services/service.goindex f9be00d6..0be96135 100644--- a/backend/internal/features/backups/backups/services/service.go+++ b/backend/internal/features/backups/backups/services/service.go@@ -63,6 +63,12 @@ func (s *BackupService) HasSuccessfulBackupSince(return s.backupRepository.ExistsCompletedSince(databaseID, since)}+func (s *BackupService) GetLatestCompletedBackup(+ databaseID uuid.UUID,+) (*backups_core.Backup, error) {+ return s.backupRepository.FindLatestCompleted(databaseID)+}+func (s *BackupService) OnBeforeBackupsStorageChange(databaseID uuid.UUID) error {err := s.deleteDbBackups(databaseID)if err != nil {diff --git a/backend/internal/features/backups/backups/usecases/mariadb/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/mariadb/create_backup_uc.goindex 096ccf93..04acbad0 100644--- a/backend/internal/features/backups/backups/usecases/mariadb/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/mariadb/create_backup_uc.go@@ -78,6 +78,15 @@ func (uc *CreateMariadbBackupUsecase) Execute(return nil, fmt.Errorf("failed to decrypt database password: %w", err)}+ rawSizeMB, err := mdb.GetRawDbSizeMb(ctx, uc.logger, uc.fieldEncryptor, db.ID)+ if err != nil {+ uc.logger.Warn("failed to fetch raw db size before backup",+ "database_id", db.ID,+ "error", err)+ } else {+ backup.BackupRawDbSizeMb = rawSizeMB+ }+args := uc.buildMariadbDumpArgs(mdb)return uc.streamToStorage(diff --git a/backend/internal/features/backups/backups/usecases/mongodb/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/mongodb/create_backup_uc.goindex 0dd345da..49fefe99 100644--- a/backend/internal/features/backups/backups/usecases/mongodb/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/mongodb/create_backup_uc.go@@ -72,6 +72,15 @@ func (uc *CreateMongodbBackupUsecase) Execute(return nil, fmt.Errorf("failed to decrypt database password: %w", err)}+ rawSizeMB, err := mdb.GetRawDbSizeMb(ctx, uc.logger, uc.fieldEncryptor, db.ID)+ if err != nil {+ uc.logger.Warn("failed to fetch raw db size before backup",+ "database_id", db.ID,+ "error", err)+ } else {+ backup.BackupRawDbSizeMb = rawSizeMB+ }+args := uc.buildMongodumpArgs(mdb, decryptedPassword)return uc.streamToStorage(diff --git a/backend/internal/features/backups/backups/usecases/mysql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/mysql/create_backup_uc.goindex ec33e44f..8e742e39 100644--- a/backend/internal/features/backups/backups/usecases/mysql/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/mysql/create_backup_uc.go@@ -78,6 +78,15 @@ func (uc *CreateMysqlBackupUsecase) Execute(return nil, fmt.Errorf("failed to decrypt database password: %w", err)}+ rawSizeMB, err := my.GetRawDbSizeMb(ctx, uc.logger, uc.fieldEncryptor, db.ID)+ if err != nil {+ uc.logger.Warn("failed to fetch raw db size before backup",+ "database_id", db.ID,+ "error", err)+ } else {+ backup.BackupRawDbSizeMb = rawSizeMB+ }+args := uc.buildMysqldumpArgs(my)return uc.streamToStorage(diff --git a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.goindex 05e13a3b..8554da32 100644--- a/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go+++ b/backend/internal/features/backups/backups/usecases/postgresql/create_backup_uc.go@@ -86,6 +86,15 @@ func (uc *CreatePostgresqlBackupUsecase) Execute(return nil, fmt.Errorf("failed to decrypt database password: %w", err)}+ rawSizeMB, err := pg.GetRawDbSizeMb(ctx, uc.logger, uc.fieldEncryptor, db.ID)+ if err != nil {+ uc.logger.Warn("failed to fetch raw db size before backup",+ "database_id", db.ID,+ "error", err)+ } else {+ backup.BackupRawDbSizeMb = rawSizeMB+ }+return uc.streamToStorage(ctx,backup,diff --git a/backend/internal/features/databases/databases/mariadb/model.go b/backend/internal/features/databases/databases/mariadb/model.goindex aa84f990..9b7f5d7b 100644--- a/backend/internal/features/databases/databases/mariadb/model.go+++ b/backend/internal/features/databases/databases/mariadb/model.go@@ -111,6 +111,51 @@ func (m *MariadbDatabase) TestConnection(return nil}+func (m *MariadbDatabase) GetRawDbSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+) (float64, error) {+ if m.Database == nil || *m.Database == "" {+ return 0, nil+ }++ password, err := decryptPasswordIfNeeded(m.Password, encryptor, databaseID)+ if err != nil {+ return 0, fmt.Errorf("failed to decrypt password: %w", err)+ }++ dsn := m.buildDSN(password, *m.Database)++ db, err := sql.Open("mysql", dsn)+ if err != nil {+ return 0, fmt.Errorf("failed to connect to MariaDB database '%s': %w", *m.Database, err)+ }+ defer func() {+ if closeErr := db.Close(); closeErr != nil {+ logger.Error("Failed to close MariaDB connection", "error", closeErr)+ }+ }()++ db.SetConnMaxLifetime(15 * time.Second)+ db.SetMaxOpenConns(1)+ db.SetMaxIdleConns(1)++ const query = `+ SELECT COALESCE(SUM(data_length + index_length), 0) / (1024 * 1024)+ FROM information_schema.tables+ WHERE table_schema = ?+ `++ var sizeMB float64+ if err := db.QueryRowContext(ctx, query, *m.Database).Scan(&sizeMB); err != nil {+ return 0, fmt.Errorf("failed to query MariaDB database size: %w", err)+ }++ return sizeMB, nil+}+func (m *MariadbDatabase) HideSensitiveData() {if m == nil {returndiff --git a/backend/internal/features/databases/databases/mariadb/model_test.go b/backend/internal/features/databases/databases/mariadb/model_test.goindex e1d699da..9ab5f332 100644--- a/backend/internal/features/databases/databases/mariadb/model_test.go+++ b/backend/internal/features/databases/databases/mariadb/model_test.go@@ -812,6 +812,41 @@ type MariadbContainer struct {DB *sqlx.DB}+func Test_GetRawDbSizeMb_Mariadb_ReturnsPositiveSize(t *testing.T) {+ env := config.GetEnv()+ container := connectToMariadbContainer(t, env.TestMariadb1011Port, tools.MariadbVersion1011)+ defer container.DB.Close()++ tableName := fmt.Sprintf("size_test_%s", uuid.New().String()[:8])+ _, err := container.DB.Exec(fmt.Sprintf(+ `CREATE TABLE %s (id INT AUTO_INCREMENT PRIMARY KEY, payload TEXT NOT NULL)`,+ tableName,+ ))+ assert.NoError(t, err)+ defer func() {+ _, _ = container.DB.Exec(fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName))+ }()++ for i := 0; i < 1000; i++ {+ _, err = container.DB.Exec(+ fmt.Sprintf("INSERT INTO %s (payload) VALUES (?)", tableName),+ strings.Repeat("x", 1024),+ )+ assert.NoError(t, err)+ }++ _, err = container.DB.Exec("ANALYZE TABLE " + tableName)+ assert.NoError(t, err)++ mariadbModel := createMariadbModel(container)++ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ sizeMB, err := mariadbModel.GetRawDbSizeMb(t.Context(), logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.Greater(t, sizeMB, 0.0, "raw db size should be > 0 after inserting data")+}+func connectToMariadbContainer(t *testing.T,port string,diff --git a/backend/internal/features/databases/databases/mongodb/model.go b/backend/internal/features/databases/databases/mongodb/model.goindex 8f317f7b..0886f2f3 100644--- a/backend/internal/features/databases/databases/mongodb/model.go+++ b/backend/internal/features/databases/databases/mongodb/model.go@@ -117,6 +117,49 @@ func (m *MongodbDatabase) TestConnection(return nil}+// GetRawDbSizeMb reads dataSize from the dbStats command — the uncompressed+// total of user data, the closest analog to the relational "raw DB size".+func (m *MongodbDatabase) GetRawDbSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+) (float64, error) {+ if m.Database == "" {+ return 0, nil+ }++ password, err := decryptPasswordIfNeeded(m.Password, encryptor, databaseID)+ if err != nil {+ return 0, fmt.Errorf("failed to decrypt password: %w", err)+ }++ uri := m.buildConnectionURI(password)++ clientOptions := options.Client().ApplyURI(uri)+ client, err := mongo.Connect(ctx, clientOptions)+ if err != nil {+ return 0, fmt.Errorf("failed to connect to MongoDB: %w", err)+ }+ defer func() {+ if disconnectErr := client.Disconnect(ctx); disconnectErr != nil {+ logger.Error("Failed to disconnect from MongoDB", "error", disconnectErr)+ }+ }()++ result := client.Database(m.Database).RunCommand(ctx, bson.D{{Key: "dbStats", Value: 1}})++ var stats struct {+ DataSize float64 `bson:"dataSize"`+ }++ if err := result.Decode(&stats); err != nil {+ return 0, fmt.Errorf("failed to decode dbStats for MongoDB database '%s': %w", m.Database, err)+ }++ return stats.DataSize / (1024 * 1024), nil+}+func (m *MongodbDatabase) HideSensitiveData() {if m == nil {returndiff --git a/backend/internal/features/databases/databases/mongodb/model_test.go b/backend/internal/features/databases/databases/mongodb/model_test.goindex 84b94de6..df181dc0 100644--- a/backend/internal/features/databases/databases/mongodb/model_test.go+++ b/backend/internal/features/databases/databases/mongodb/model_test.go@@ -388,6 +388,34 @@ type MongodbContainer struct {Client *mongo.Client}+func Test_GetRawDbSizeMb_Mongodb_ReturnsPositiveSize(t *testing.T) {+ env := config.GetEnv()+ container := connectToMongodbContainer(t, env.TestMongodb70Port, tools.MongodbVersion7)+ defer container.Client.Disconnect(t.Context())++ collectionName := fmt.Sprintf("size_test_%s", uuid.New().String()[:8])+ collection := container.Client.Database(container.Database).Collection(collectionName)++ defer func() {+ _ = collection.Drop(t.Context())+ }()++ docs := make([]any, 0, 1000)+ for i := 0; i < 1000; i++ {+ docs = append(docs, bson.M{"payload": strings.Repeat("x", 1024)})+ }+ _, err := collection.InsertMany(t.Context(), docs)+ assert.NoError(t, err)++ mongodbModel := createMongodbModel(container)++ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ sizeMB, err := mongodbModel.GetRawDbSizeMb(t.Context(), logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.Greater(t, sizeMB, 0.0, "raw db size should be > 0 after inserting documents")+}+func connectToMongodbContainer(t *testing.T,port string,diff --git a/backend/internal/features/databases/databases/mysql/model.go b/backend/internal/features/databases/databases/mysql/model.goindex 92aabb7e..bea081f1 100644--- a/backend/internal/features/databases/databases/mysql/model.go+++ b/backend/internal/features/databases/databases/mysql/model.go@@ -112,6 +112,51 @@ func (m *MysqlDatabase) TestConnection(return nil}+func (m *MysqlDatabase) GetRawDbSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+) (float64, error) {+ if m.Database == nil || *m.Database == "" {+ return 0, nil+ }++ password, err := decryptPasswordIfNeeded(m.Password, encryptor, databaseID)+ if err != nil {+ return 0, fmt.Errorf("failed to decrypt password: %w", err)+ }++ dsn := m.buildDSN(password, *m.Database)++ db, err := sql.Open("mysql", dsn)+ if err != nil {+ return 0, fmt.Errorf("failed to connect to MySQL database '%s': %w", *m.Database, err)+ }+ defer func() {+ if closeErr := db.Close(); closeErr != nil {+ logger.Error("Failed to close MySQL connection", "error", closeErr)+ }+ }()++ db.SetConnMaxLifetime(15 * time.Second)+ db.SetMaxOpenConns(1)+ db.SetMaxIdleConns(1)++ const query = `+ SELECT COALESCE(SUM(data_length + index_length), 0) / (1024 * 1024)+ FROM information_schema.tables+ WHERE table_schema = ?+ `++ var sizeMB float64+ if err := db.QueryRowContext(ctx, query, *m.Database).Scan(&sizeMB); err != nil {+ return 0, fmt.Errorf("failed to query MySQL database size: %w", err)+ }++ return sizeMB, nil+}+func (m *MysqlDatabase) HideSensitiveData() {if m == nil {returndiff --git a/backend/internal/features/databases/databases/mysql/model_test.go b/backend/internal/features/databases/databases/mysql/model_test.goindex 0d0ee9ed..3827b242 100644--- a/backend/internal/features/databases/databases/mysql/model_test.go+++ b/backend/internal/features/databases/databases/mysql/model_test.go@@ -821,6 +821,41 @@ type MysqlContainer struct {DB *sqlx.DB}+func Test_GetRawDbSizeMb_Mysql_ReturnsPositiveSize(t *testing.T) {+ env := config.GetEnv()+ container := connectToMysqlContainer(t, env.TestMysql80Port, tools.MysqlVersion80)+ defer container.DB.Close()++ tableName := fmt.Sprintf("size_test_%s", uuid.New().String()[:8])+ _, err := container.DB.Exec(fmt.Sprintf(+ `CREATE TABLE %s (id INT AUTO_INCREMENT PRIMARY KEY, payload TEXT NOT NULL)`,+ tableName,+ ))+ assert.NoError(t, err)+ defer func() {+ _, _ = container.DB.Exec(fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName))+ }()++ for i := 0; i < 1000; i++ {+ _, err = container.DB.Exec(+ fmt.Sprintf("INSERT INTO %s (payload) VALUES (?)", tableName),+ strings.Repeat("x", 1024),+ )+ assert.NoError(t, err)+ }++ _, err = container.DB.Exec("ANALYZE TABLE " + tableName)+ assert.NoError(t, err)++ mysqlModel := createMysqlModel(container)++ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ sizeMB, err := mysqlModel.GetRawDbSizeMb(t.Context(), logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.Greater(t, sizeMB, 0.0, "raw db size should be > 0 after inserting data")+}+func connectToMysqlContainer(t *testing.T,port string,diff --git a/backend/internal/features/databases/databases/postgresql/model.go b/backend/internal/features/databases/databases/postgresql/model.goindex 5503d604..a7f60f24 100644--- a/backend/internal/features/databases/databases/postgresql/model.go+++ b/backend/internal/features/databases/databases/postgresql/model.go@@ -161,6 +161,47 @@ func (p *PostgresqlDatabase) TestConnection(return testSingleDatabaseConnection(logger, ctx, p, encryptor, databaseID)}+// GetRawDbSizeMb returns whole-database size via pg_database_size; when+// IncludeSchemas filters the dump, the value remains the full DB size.+func (p *PostgresqlDatabase) GetRawDbSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+) (float64, error) {+ if p.BackupType == PostgresBackupTypeWalV1 {+ return 0, nil+ }++ if p.Database == nil || *p.Database == "" {+ return 0, nil+ }++ password, err := decryptPasswordIfNeeded(p.Password, encryptor, databaseID)+ if err != nil {+ return 0, fmt.Errorf("failed to decrypt password: %w", err)+ }++ connStr := buildConnectionStringForDB(p, *p.Database, password)++ conn, err := pgx.Connect(ctx, connStr)+ if err != nil {+ return 0, fmt.Errorf("failed to connect to database '%s': %w", *p.Database, err)+ }+ defer func() {+ if closeErr := conn.Close(ctx); closeErr != nil {+ logger.Error("Failed to close connection", "error", closeErr)+ }+ }()++ var sizeBytes int64+ if err := conn.QueryRow(ctx, "SELECT pg_database_size(current_database())").Scan(&sizeBytes); err != nil {+ return 0, fmt.Errorf("failed to query pg_database_size: %w", err)+ }++ return float64(sizeBytes) / (1024 * 1024), nil+}+func (p *PostgresqlDatabase) HideSensitiveData() {if p == nil {returndiff --git a/backend/internal/features/databases/databases/postgresql/model_test.go b/backend/internal/features/databases/databases/postgresql/model_test.goindex dd808508..805d7057 100644--- a/backend/internal/features/databases/databases/postgresql/model_test.go+++ b/backend/internal/features/databases/databases/postgresql/model_test.go@@ -1586,6 +1586,31 @@ func Test_CreateReadOnlyUser_WithIncludeSchemas_OnlyGrantsAccessToSpecifiedSchem)}+func Test_GetRawDbSizeMb_Postgresql_ReturnsPositiveSize(t *testing.T) {+ env := config.GetEnv()+ container := connectToPostgresContainer(t, env.TestPostgres16Port)+ defer container.DB.Close()++ tableName := fmt.Sprintf("size_test_%s", uuid.New().String()[:8])+ _, err := container.DB.Exec(fmt.Sprintf(`+ CREATE TABLE %s (id SERIAL PRIMARY KEY, payload TEXT NOT NULL);+ INSERT INTO %s (payload) SELECT repeat('x', 1024) FROM generate_series(1, 10000);+ `, tableName, tableName))+ assert.NoError(t, err)+ defer func() {+ _, _ = container.DB.Exec(fmt.Sprintf("DROP TABLE IF EXISTS %s", tableName))+ }()++ pgModel := createPostgresModel(container)+ assert.NotNil(t, pgModel)++ logger := slog.New(slog.NewTextHandler(os.Stdout, nil))++ sizeMB, err := pgModel.GetRawDbSizeMb(t.Context(), logger, nil, uuid.New())+ assert.NoError(t, err)+ assert.Greater(t, sizeMB, 0.0, "raw db size should be > 0 after inserting data")+}+func connectToPostgresContainer(t *testing.T, port string) *PostgresContainer {dbName := "testdb"password := "testpassword"diff --git a/backend/internal/features/databases/interfaces.go b/backend/internal/features/databases/interfaces.goindex 48518108..148b7d70 100644--- a/backend/internal/features/databases/interfaces.go+++ b/backend/internal/features/databases/interfaces.go@@ -1,6 +1,7 @@package databasesimport (+ "context""log/slog""github.com/google/uuid"@@ -19,6 +20,13 @@ type DatabaseConnector interface {databaseID uuid.UUID,) error+ GetRawDbSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+ databaseID uuid.UUID,+ ) (float64, error)+HideSensitiveData()}diff --git a/backend/internal/features/databases/model.go b/backend/internal/features/databases/model.goindex f13e7a7b..187d82fd 100644--- a/backend/internal/features/databases/model.go+++ b/backend/internal/features/databases/model.go@@ -100,6 +100,14 @@ func (d *Database) TestConnection(return d.getSpecificDatabase().TestConnection(logger, encryptor, d.ID)}+func (d *Database) GetRawDbSizeMb(+ ctx context.Context,+ logger *slog.Logger,+ encryptor encryption.FieldEncryptor,+) (float64, error) {+ return d.getSpecificDatabase().GetRawDbSizeMb(ctx, logger, encryptor, d.ID)+}+func (d *Database) IsUserReadOnly(ctx context.Context,logger *slog.Logger,diff --git a/backend/internal/features/telemetry/dto.go b/backend/internal/features/telemetry/dto.goindex 47e0ac47..b73a78d9 100644--- a/backend/internal/features/telemetry/dto.go+++ b/backend/internal/features/telemetry/dto.go@@ -1,8 +1,10 @@package telemetrytype DatabaseEntry struct {- Type string `json:"type"`- Version string `json:"version"`+ Type string `json:"type"`+ Version string `json:"version"`+ RawSizeMb int64 `json:"rawSizeMb,omitzero"`+ BackupSizeMb int64 `json:"backupSizeMb,omitzero"`}type CollectRequest struct {diff --git a/backend/internal/features/telemetry/service.go b/backend/internal/features/telemetry/service.goindex 0778db5f..3c796a54 100644--- a/backend/internal/features/telemetry/service.go+++ b/backend/internal/features/telemetry/service.go@@ -3,12 +3,14 @@ package telemetryimport ("context""log/slog"+ "math""runtime""sort""time""github.com/google/uuid"+ backups_core "databasus-backend/internal/features/backups/backups/core""databasus-backend/internal/features/databases""databasus-backend/internal/features/notifiers""databasus-backend/internal/features/storages"@@ -37,6 +39,7 @@ type notifierLister interface {type backupChecker interface {HasSuccessfulBackupSince(databaseID uuid.UUID, since time.Time) (bool, error)+ GetLatestCompletedBackup(databaseID uuid.UUID) (*backups_core.Backup, error)}type TelemetryService struct {@@ -131,12 +134,40 @@ func (s *TelemetryService) collectActiveDatabases() ([]DatabaseEntry, error) {continue}+ if err := s.attachBackupSizes(&entry, db.ID); err != nil {+ return nil, err+ }+entries = append(entries, entry)}return entries, nil}+func (s *TelemetryService) attachBackupSizes(+ entry *DatabaseEntry,+ databaseID uuid.UUID,+) error {+ backup, err := s.backupService.GetLatestCompletedBackup(databaseID)+ if err != nil {+ return err+ }++ if backup == nil {+ return nil+ }++ if backup.BackupSizeMb > 0 {+ entry.BackupSizeMb = int64(math.Round(backup.BackupSizeMb))+ }++ if backup.BackupRawDbSizeMb > 0 {+ entry.RawSizeMb = int64(math.Round(backup.BackupRawDbSizeMb))+ }++ return nil+}+// isDatabaseActive returns true when a database should be counted in telemetry.//// - HealthStatus == AVAILABLE → active.@@ -187,20 +218,13 @@ func (s *TelemetryService) collectStorageTypes() ([]string, error) {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)}@@ -214,20 +238,13 @@ func (s *TelemetryService) collectNotifierTypes() ([]string, error) {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)}diff --git a/backend/internal/features/telemetry/service_test.go b/backend/internal/features/telemetry/service_test.goindex 4add9cbd..5986cbed 100644--- a/backend/internal/features/telemetry/service_test.go+++ b/backend/internal/features/telemetry/service_test.go@@ -2,6 +2,7 @@ package telemetryimport ("context"+ "encoding/json""errors""log/slog""os"@@ -14,6 +15,7 @@ import ("github.com/stretchr/testify/assert""github.com/stretchr/testify/require"+ backups_core "databasus-backend/internal/features/backups/backups/core""databasus-backend/internal/features/databases""databasus-backend/internal/features/databases/databases/mariadb""databasus-backend/internal/features/databases/databases/mongodb"@@ -63,7 +65,9 @@ func (f *fakeNotifierLister) GetAllNotifiers() ([]*notifiers.Notifier, error) {type fakeBackupChecker struct {hasBackupSince map[uuid.UUID]bool+ latestBackups map[uuid.UUID]*backups_core.Backuperr error+ latestErr error}func (f *fakeBackupChecker) HasSuccessfulBackupSince(@@ -77,6 +81,16 @@ func (f *fakeBackupChecker) HasSuccessfulBackupSince(return f.hasBackupSince[databaseID], nil}+func (f *fakeBackupChecker) GetLatestCompletedBackup(+ databaseID uuid.UUID,+) (*backups_core.Backup, error) {+ if f.latestErr != nil {+ return nil, f.latestErr+ }++ return f.latestBackups[databaseID], nil+}+func newServiceUnderTest(t *testing.T,databaseLister databaseLister,@@ -190,12 +204,13 @@ func Test_BuildAndSend_ProducesExpectedRequest(t *testing.T) {require.NoError(t, err)}-func Test_BuildAndSend_DedupesStoragesAndNotifiers(t *testing.T) {+func Test_BuildAndSend_PreservesStorageAndNotifierDuplicates(t *testing.T) {sender := &fakeSender{}service := newServiceUnderTest(t,&fakeDatabaseLister{},&fakeStorageLister{storages: []*storages.Storage{+ {Type: storages.StorageTypeS3},{Type: storages.StorageTypeS3},{Type: storages.StorageTypeS3},{Type: storages.StorageTypeLocal},@@ -212,8 +227,8 @@ func Test_BuildAndSend_DedupesStoragesAndNotifiers(t *testing.T) {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)+ assert.Equal(t, []string{"LOCAL", "S3", "S3", "S3"}, sender.calls[0].Storages)+ assert.Equal(t, []string{"EMAIL", "EMAIL", "TELEGRAM"}, sender.calls[0].Notifiers)}func Test_BuildAndSend_WhenInstanceFileFails_DoesNotCallSender(t *testing.T) {@@ -354,6 +369,136 @@ func Test_BuildAndSend_WhenBackupCheckerFails_ReturnsError(t *testing.T) {assert.Empty(t, sender.calls)}+func Test_BuildAndSend_WhenLatestBackupHasBothSizes_IncludesBoth(t *testing.T) {+ db := postgresDatabase("pg", availableStatus())++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{+ latestBackups: map[uuid.UUID]*backups_core.Backup{+ db.ID: {BackupSizeMb: 870.4, BackupRawDbSizeMb: 4321.7},+ },+ },+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ require.Len(t, sender.calls[0].Databases, 1)++ entry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(870), entry.BackupSizeMb)+ assert.Equal(t, int64(4322), entry.RawSizeMb)+}++func Test_BuildAndSend_WhenRawSizeZero_IncludesOnlyBackupSize(t *testing.T) {+ db := postgresDatabase("pg", availableStatus())++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{+ latestBackups: map[uuid.UUID]*backups_core.Backup{+ db.ID: {BackupSizeMb: 100, BackupRawDbSizeMb: 0},+ },+ },+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ require.Len(t, sender.calls[0].Databases, 1)++ entry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(100), entry.BackupSizeMb)+ assert.Equal(t, int64(0), entry.RawSizeMb)++ encoded, err := json.Marshal(entry)+ require.NoError(t, err)+ assert.NotContains(t, string(encoded), "rawSizeMb")+ assert.Contains(t, string(encoded), "backupSizeMb")+}++func Test_BuildAndSend_WhenBackupSizeZero_IncludesOnlyRawSize(t *testing.T) {+ db := postgresDatabase("pg", availableStatus())++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{+ latestBackups: map[uuid.UUID]*backups_core.Backup{+ db.ID: {BackupSizeMb: 0, BackupRawDbSizeMb: 999},+ },+ },+ sender,+ )++ require.NoError(t, service.BuildAndSend(context.Background()))+ require.Len(t, sender.calls, 1)+ require.Len(t, sender.calls[0].Databases, 1)++ entry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(0), entry.BackupSizeMb)+ assert.Equal(t, int64(999), entry.RawSizeMb)+}++func Test_BuildAndSend_WhenNoCompletedBackup_OmitsBothSizes(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)+ require.Len(t, sender.calls[0].Databases, 1)++ entry := sender.calls[0].Databases[0]+ assert.Equal(t, int64(0), entry.BackupSizeMb)+ assert.Equal(t, int64(0), entry.RawSizeMb)++ encoded, err := json.Marshal(entry)+ require.NoError(t, err)+ assert.NotContains(t, string(encoded), "rawSizeMb")+ assert.NotContains(t, string(encoded), "backupSizeMb")+}++func Test_BuildAndSend_WhenLatestBackupLookupFails_ReturnsError(t *testing.T) {+ db := postgresDatabase("pg", availableStatus())+ lookupErr := errors.New("query exploded")++ sender := &fakeSender{}+ service := newServiceUnderTest(+ t,+ &fakeDatabaseLister{databases: []*databases.Database{db}},+ &fakeStorageLister{},+ &fakeNotifierLister{},+ &fakeBackupChecker{latestErr: lookupErr},+ sender,+ )++ err := service.BuildAndSend(context.Background())+ require.Error(t, err)+ assert.ErrorIs(t, err, lookupErr)+ assert.Empty(t, sender.calls)+}+func writeFileForTest(path string) error {return os.WriteFile(path, []byte("x"), 0o600)}diff --git a/backend/migrations/20260505120000_add_backup_raw_db_size_to_backups.sql b/backend/migrations/20260505120000_add_backup_raw_db_size_to_backups.sqlnew file mode 100644index 00000000..a01ed2cf--- /dev/null+++ b/backend/migrations/20260505120000_add_backup_raw_db_size_to_backups.sql@@ -0,0 +1,7 @@+-- +goose Up+ALTER TABLE backups+ ADD COLUMN backup_raw_db_size_mb DOUBLE PRECISION NOT NULL DEFAULT 0;++-- +goose Down+ALTER TABLE backups+ DROP COLUMN backup_raw_db_size_mb;diff --git a/frontend/src/entity/backups/model/Backup.ts b/frontend/src/entity/backups/model/Backup.tsindex 616a239a..b3c29e9c 100644--- a/frontend/src/entity/backups/model/Backup.ts+++ b/frontend/src/entity/backups/model/Backup.ts@@ -11,6 +11,7 @@ export interface Backup {status: BackupStatus;failMessage?: string;backupSizeMb: number;+ backupRawDbSizeMb: number;backupDurationMs: number;encryption: BackupEncryption;pgWalBackupType?: PgWalBackupType;diff --git a/frontend/src/features/backups/ui/BackupsComponent.tsx b/frontend/src/features/backups/ui/BackupsComponent.tsxindex 87c1ea93..73011bb9 100644--- a/frontend/src/features/backups/ui/BackupsComponent.tsx+++ b/frontend/src/features/backups/ui/BackupsComponent.tsx@@ -454,7 +454,7 @@ export const BackupsComponent = ({Size<TooltipclassName="ml-1"- title="The file size we actually store in the storage (local, S3, Google Drive, etc.), usually compressed in ~5x times"+ title="Top: the compressed backup file size we actually store in the storage (local, S3, Google Drive, etc.). Bottom (grayed): the original uncompressed database size at backup time. Backups are usually compressed ~5x."><InfoCircleOutlined /></Tooltip>@@ -464,17 +464,24 @@ export const BackupsComponent = ({key: 'backupSizeMb',width: 150,render: (sizeMb: number, record: Backup) => (- <div className="flex items-center gap-2">- {formatSize(sizeMb)}- {record.pgWalBackupType === PgWalBackupType.PG_FULL_BACKUP && (- <span className="rounded bg-blue-100 px-1.5 py-0.5 text-xs font-medium text-blue-700 dark:bg-blue-900 dark:text-blue-300">- FULL- </span>- )}- {record.pgWalBackupType === PgWalBackupType.PG_WAL_SEGMENT && (- <span className="rounded bg-purple-100 px-1.5 py-0.5 text-xs font-medium text-purple-700 dark:bg-purple-900 dark:text-purple-300">- WAL- </span>+ <div>+ <div className="flex items-center gap-2">+ {formatSize(sizeMb)}+ {record.pgWalBackupType === PgWalBackupType.PG_FULL_BACKUP && (+ <span className="rounded bg-blue-100 px-1.5 py-0.5 text-xs font-medium text-blue-700 dark:bg-blue-900 dark:text-blue-300">+ FULL+ </span>+ )}+ {record.pgWalBackupType === PgWalBackupType.PG_WAL_SEGMENT && (+ <span className="rounded bg-purple-100 px-1.5 py-0.5 text-xs font-medium text-purple-700 dark:bg-purple-900 dark:text-purple-300">+ WAL+ </span>+ )}+ </div>+ {record.backupRawDbSizeMb > 0 && (+ <div className="text-xs text-gray-500 dark:text-gray-500">+ {formatSize(record.backupRawDbSizeMb)} (DB size)+ </div>)}</div>),@@ -616,6 +623,11 @@ export const BackupsComponent = ({</span>)}</div>+ {backup.backupRawDbSizeMb > 0 && (+ <div className="text-xs text-gray-500 dark:text-gray-500">+ {formatSize(backup.backupRawDbSizeMb)} (DB size)+ </div>+ )}</div><div><div className="text-xs text-gray-500 dark:text-gray-400">Duration</div>