Skip to content

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

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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 {
return
diff --git a/backend/internal/features/databases/databases/mariadb/model_test.go b/backend/internal/features/databases/databases/mariadb/model_test.go
index 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.go
index 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 {
return
diff --git a/backend/internal/features/databases/databases/mongodb/model_test.go b/backend/internal/features/databases/databases/mongodb/model_test.go
index 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.go
index 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 {
return
diff --git a/backend/internal/features/databases/databases/mysql/model_test.go b/backend/internal/features/databases/databases/mysql/model_test.go
index 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.go
index 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 {
return
diff --git a/backend/internal/features/databases/databases/postgresql/model_test.go b/backend/internal/features/databases/databases/postgresql/model_test.go
index 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.go
index 48518108..148b7d70 100644
--- a/backend/internal/features/databases/interfaces.go
+++ b/backend/internal/features/databases/interfaces.go
@@ -1,6 +1,7 @@
package databases
import (
+ "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.go
index 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.go
index 47e0ac47..b73a78d9 100644
--- a/backend/internal/features/telemetry/dto.go
+++ b/backend/internal/features/telemetry/dto.go
@@ -1,8 +1,10 @@
package telemetry
type 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.go
index 0778db5f..3c796a54 100644
--- a/backend/internal/features/telemetry/service.go
+++ b/backend/internal/features/telemetry/service.go
@@ -3,12 +3,14 @@ package telemetry
import (
"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.go
index 4add9cbd..5986cbed 100644
--- a/backend/internal/features/telemetry/service_test.go
+++ b/backend/internal/features/telemetry/service_test.go
@@ -2,6 +2,7 @@ package telemetry
import (
"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.Backup
err 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.sql
new file mode 100644
index 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.ts
index 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.tsx
index 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
<Tooltip
className="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>