feat: comprehensive sentry instrumentation (#2023)

* feat: comprehensive sentry instrumentation

* test: pass

* fix: only fetch zitadel dsn in zitadel-operator

* chore: use dns for sentry environment as soon as parsed

* fix: trust ca certs

* ci: update orbos

* docs: add usage data explanation

* fix: dont send validation errors

* docs: improve ingestion data explanation

* style: rename flag --disable-ingestion to --disable-analytics

* fix: pass --disable-analytics flag to self deployments

* fix: destroy command for sentry

* fix: update orbos

* fix: only switch environment if analytics is enabled

* fix: ensure SENTRY_DSN is always set

* test: test empty sentry dsn

* ci: invalidate build caches

* chore: use zitadel-dev if no version is passed

* chore: combine dev releases in sentry

* refactor: only check for semrel if sentry is enabled

operator/database/kinds/backups/backups.go

@@ -1,6 +1,10 @@
 package backups
 
 import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/labels"
@@ -8,8 +12,6 @@ import (
 	"github.com/caos/orbos/pkg/tree"
 	"github.com/caos/zitadel/operator"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket"
-	"github.com/pkg/errors"
-	corev1 "k8s.io/api/core/v1"
 )
 
 func Adapt(
@@ -44,7 +46,7 @@ func Adapt(
 				labels.MustReplaceAPI(
 					labels.GetAPIFromComponent(componentLabels),
 					"BucketBackup",
-					desiredTree.Common.Version,
+					desiredTree.Common.Version(),
 				),
 				"backup"),
 			checkDBReady,
@@ -56,7 +58,7 @@ func Adapt(
 			customImageRegistry,
 		)(monitor, desiredTree, currentTree)
 	default:
-		return nil, nil, nil, nil, nil, false, errors.Errorf("unknown database kind %s", desiredTree.Common.Kind)
+		return nil, nil, nil, nil, nil, false, mntr.ToUserError(fmt.Errorf("unknown database kind %s", desiredTree.Common.Kind))
 	}
 }
 
@@ -73,6 +75,6 @@ func GetBackupList(
 	case "databases.caos.ch/BucketBackup":
 		return bucket.BackupList()(monitor, k8sClient, name, desiredTree)
 	default:
-		return nil, errors.Errorf("unknown database kind %s", desiredTree.Common.Kind)
+		return nil, mntr.ToUserError(fmt.Errorf("unknown database kind %s", desiredTree.Common.Kind))
 	}
 }

operator/database/kinds/backups/bucket/adapt.go

@@ -1,6 +1,10 @@
 package bucket
 
 import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/kubernetes/resources/secret"
@@ -8,14 +12,13 @@ import (
 	secretpkg "github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/secret/read"
 	"github.com/caos/orbos/pkg/tree"
+	coreDB "github.com/caos/zitadel/operator/database/kinds/databases/core"
+
 	"github.com/caos/zitadel/operator"
 	"github.com/caos/zitadel/operator/common"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket/backup"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket/clean"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket/restore"
-	coreDB "github.com/caos/zitadel/operator/database/kinds/databases/core"
-	"github.com/pkg/errors"
-	corev1 "k8s.io/api/core/v1"
 )
 
 const (
@@ -53,7 +56,7 @@ func AdaptFunc(
 
 		desiredKind, err := ParseDesiredV0(desired)
 		if err != nil {
-			return nil, nil, nil, nil, nil, false, errors.Wrap(err, "parsing desired state failed")
+			return nil, nil, nil, nil, nil, false, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		desired.Parsed = desiredKind
 

operator/database/kinds/backups/bucket/adapt_test.go

@@ -39,10 +39,7 @@ func TestBucket_Secrets(t *testing.T) {
 	version := "testVersion2"
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/" + kind,
-			Version: kindVersion,
-		},
+		Common: tree.NewCommon("databases.caos.ch/"+kind, kindVersion, false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,
@@ -114,10 +111,7 @@ func TestBucket_AdaptBackup(t *testing.T) {
 	version := "testVersion2"
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,
@@ -189,10 +183,7 @@ func TestBucket_AdaptInstantBackup(t *testing.T) {
 	saJson := "testSA"
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,
@@ -265,10 +256,7 @@ func TestBucket_AdaptRestore(t *testing.T) {
 	saJson := "testSA"
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,
@@ -341,10 +329,7 @@ func TestBucket_AdaptClean(t *testing.T) {
 	saJson := "testSA"
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,

operator/database/kinds/backups/bucket/backup/cleanup.go

@@ -1,10 +1,12 @@
 package backup
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
+
 	"github.com/caos/zitadel/operator"
-	"github.com/pkg/errors"
 )
 
 func GetCleanupFunc(
@@ -15,13 +17,11 @@ func GetCleanupFunc(
 	return func(k8sClient kubernetes.ClientInt) error {
 		monitor.Info("waiting for backup to be completed")
 		if err := k8sClient.WaitUntilJobCompleted(namespace, GetJobName(backupName), timeout); err != nil {
-			monitor.Error(errors.Wrap(err, "error while waiting for backup to be completed"))
-			return err
+			return fmt.Errorf("error while waiting for backup to be completed: %w", err)
 		}
 		monitor.Info("backup is completed, cleanup")
 		if err := k8sClient.DeleteJob(namespace, GetJobName(backupName)); err != nil {
-			monitor.Error(errors.Wrap(err, "error while trying to cleanup backup"))
-			return err
+			return fmt.Errorf("error while trying to cleanup backup: %w", err)
 		}
 		monitor.Info("restore backup is completed")
 		return nil

operator/database/kinds/backups/bucket/backup/cleanup_test.go

@@ -1,13 +1,14 @@
 package backup
 
 import (
+	"errors"
 	"testing"
 
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+
 	"github.com/caos/orbos/mntr"
 	kubernetesmock "github.com/caos/orbos/pkg/kubernetes/mock"
-	"github.com/golang/mock/gomock"
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/assert"
 )
 
 func TestBackup_Cleanup1(t *testing.T) {

operator/database/kinds/backups/bucket/clean/cleanup.go

@@ -1,10 +1,12 @@
 package clean
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
+
 	"github.com/caos/zitadel/operator"
-	"github.com/pkg/errors"
 )
 
 func GetCleanupFunc(
@@ -15,13 +17,11 @@ func GetCleanupFunc(
 	return func(k8sClient kubernetes.ClientInt) error {
 		monitor.Info("waiting for clean to be completed")
 		if err := k8sClient.WaitUntilJobCompleted(namespace, GetJobName(backupName), timeout); err != nil {
-			monitor.Error(errors.Wrap(err, "error while waiting for clean to be completed"))
-			return err
+			return fmt.Errorf("error while waiting for clean to be completed: %w", err)
 		}
 		monitor.Info("clean is completed, cleanup")
 		if err := k8sClient.DeleteJob(namespace, GetJobName(backupName)); err != nil {
-			monitor.Error(errors.Wrap(err, "error while trying to cleanup clean"))
-			return err
+			return fmt.Errorf("error while trying to cleanup clean: %w", err)
 		}
 		monitor.Info("clean cleanup is completed")
 		return nil

operator/database/kinds/backups/bucket/clean/cleanup_test.go

@@ -1,12 +1,14 @@
 package clean
 
 import (
+	"errors"
+	"testing"
+
+	"github.com/golang/mock/gomock"
+	"github.com/stretchr/testify/assert"
+
 	"github.com/caos/orbos/mntr"
 	kubernetesmock "github.com/caos/orbos/pkg/kubernetes/mock"
-	"github.com/golang/mock/gomock"
-	"github.com/pkg/errors"
-	"github.com/stretchr/testify/assert"
-	"testing"
 )
 
 func TestBackup_Cleanup1(t *testing.T) {

operator/database/kinds/backups/bucket/desired.go

@@ -3,9 +3,9 @@ package bucket
 import (
 	"fmt"
 
+	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/tree"
-	"github.com/pkg/errors"
 )
 
 type DesiredV0 struct {
@@ -38,7 +38,7 @@ func ParseDesiredV0(desiredTree *tree.Tree) (*DesiredV0, error) {
 	}
 
 	if err := desiredTree.Original.Decode(desiredKind); err != nil {
-		return nil, errors.Wrap(err, "parsing desired state failed")
+		return nil, mntr.ToUserError(fmt.Errorf("parsing desired state failed: %w", err))
 	}
 
 	return desiredKind, nil

operator/database/kinds/backups/bucket/desired_test.go

@@ -1,11 +1,12 @@
 package bucket
 
 import (
+	"testing"
+
 	"github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/tree"
 	"github.com/stretchr/testify/assert"
 	"gopkg.in/yaml.v3"
-	"testing"
 )
 
 const (
@@ -38,10 +39,7 @@ version: v0`
 
 var (
 	desired = DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,
@@ -54,10 +52,7 @@ var (
 		},
 	}
 	desiredWithoutSecret = DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: true,
 			Cron:    cron,
@@ -65,10 +60,7 @@ var (
 		},
 	}
 	desiredEmpty = DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &Spec{
 			Verbose: false,
 			Cron:    "",
@@ -80,10 +72,7 @@ var (
 	}
 
 	desiredNil = DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 	}
 )
 
@@ -106,7 +95,9 @@ func getDesiredTree(t *testing.T, masterkey string, desired *DesiredV0) *tree.Tr
 }
 
 func TestBucket_DesiredParse(t *testing.T) {
-	assert.Equal(t, yamlFileWithoutSecret, string(marshalYaml(t, masterkey, &desiredWithoutSecret)))
+
+	result := string(marshalYaml(t, masterkey, &desiredWithoutSecret))
+	assert.Equal(t, yamlFileWithoutSecret, result)
 
 	desiredTree := unmarshalYaml(t, masterkey, []byte(yamlFile))
 	desiredKind, err := ParseDesiredV0(desiredTree)

operator/database/kinds/backups/bucket/list.go

@@ -1,24 +1,27 @@
 package bucket
 
 import (
-	"cloud.google.com/go/storage"
 	"context"
+	"fmt"
+	"strings"
+
+	"cloud.google.com/go/storage"
+	"google.golang.org/api/iterator"
+	"google.golang.org/api/option"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/secret/read"
 	"github.com/caos/orbos/pkg/tree"
+
 	"github.com/caos/zitadel/operator/database/kinds/backups/core"
-	"github.com/pkg/errors"
-	"google.golang.org/api/iterator"
-	"google.golang.org/api/option"
-	"strings"
 )
 
 func BackupList() core.BackupListFunc {
 	return func(monitor mntr.Monitor, k8sClient kubernetes.ClientInt, name string, desired *tree.Tree) ([]string, error) {
 		desiredKind, err := ParseDesiredV0(desired)
 		if err != nil {
-			return nil, errors.Wrap(err, "parsing desired state failed")
+			return nil, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		desired.Parsed = desiredKind
 

operator/database/kinds/backups/bucket/restore/cleanup.go

@@ -1,10 +1,11 @@
 package restore
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/zitadel/operator"
-	"github.com/pkg/errors"
 )
 
 func GetCleanupFunc(
@@ -15,13 +16,11 @@ func GetCleanupFunc(
 	return func(k8sClient kubernetes.ClientInt) error {
 		monitor.Info("waiting for restore to be completed")
 		if err := k8sClient.WaitUntilJobCompleted(namespace, GetJobName(backupName), timeout); err != nil {
-			monitor.Error(errors.Wrap(err, "error while waiting for restore to be completed"))
-			return err
+			return fmt.Errorf("error while waiting for restore to be completed: %w", err)
 		}
 		monitor.Info("restore is completed, cleanup")
 		if err := k8sClient.DeleteJob(namespace, GetJobName(backupName)); err != nil {
-			monitor.Error(errors.Wrap(err, "error while trying to cleanup restore"))
-			return err
+			return fmt.Errorf("error while trying to cleanup restore: %w", err)
 		}
 		monitor.Info("restore cleanup is completed")
 		return nil

operator/database/kinds/databases/core/current.go

@@ -3,6 +3,7 @@ package core
 import (
 	"crypto/rsa"
 	"errors"
+
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/tree"
 	"github.com/caos/zitadel/operator"
@@ -48,14 +49,14 @@ func SetQueriedForDatabase(queried map[string]interface{}, databaseCurrent *tree
 func SetQueriedForDatabaseDBList(queried map[string]interface{}, databases, users []string) {
 	currentDBList := &CurrentDBList{
 		Common: &tree.Common{
-			Kind:    "DBList",
-			Version: "V0",
+			Kind: "DBList",
 		},
 		Current: &DatabaseCurrentDBList{
 			Databases: databases,
 			Users:     users,
 		},
 	}
+	currentDBList.Common.OverwriteVersion("V0")
 
 	currentDB := &tree.Tree{
 		Parsed: currentDBList,

operator/database/kinds/databases/databases.go

@@ -1,16 +1,19 @@
 package databases
 
 import (
+	"fmt"
+
+	core "k8s.io/api/core/v1"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/labels"
 	"github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/tree"
+
 	"github.com/caos/zitadel/operator"
 	"github.com/caos/zitadel/operator/database/kinds/databases/managed"
 	"github.com/caos/zitadel/operator/database/kinds/databases/provided"
-	"github.com/pkg/errors"
-	core "k8s.io/api/core/v1"
 )
 
 const (
@@ -60,7 +63,7 @@ func Adapt(
 	case "databases.caos.ch/ProvidedDatabase":
 		return provided.Adapter()(internalMonitor, desiredTree, currentTree)
 	default:
-		return nil, nil, nil, nil, nil, false, errors.Errorf("unknown database kind %s", desiredTree.Common.Kind)
+		return nil, nil, nil, nil, nil, false, mntr.ToUserError(fmt.Errorf("unknown database kind %s: %w", desiredTree.Common.Kind, err))
 	}
 }
 
@@ -76,8 +79,8 @@ func GetBackupList(
 	case "databases.caos.ch/CockroachDB":
 		return managed.BackupList()(monitor, k8sClient, desiredTree)
 	case "databases.caos.ch/ProvidedDatabse":
-		return nil, errors.Errorf("no backups supported for database kind %s", desiredTree.Common.Kind)
+		return nil, mntr.ToUserError(fmt.Errorf("no backups supported for database kind %s", desiredTree.Common.Kind))
 	default:
-		return nil, errors.Errorf("unknown database kind %s", desiredTree.Common.Kind)
+		return nil, mntr.ToUserError(fmt.Errorf("unknown database kind %s", desiredTree.Common.Kind))
 	}
 }

operator/database/kinds/databases/managed/adapt.go

@@ -1,30 +1,28 @@
 package managed
 
 import (
+	"fmt"
 	"strconv"
 	"strings"
 
-	"github.com/caos/zitadel/operator/common"
-
-	"github.com/caos/zitadel/operator"
-
-	"github.com/caos/orbos/pkg/labels"
-
-	"github.com/caos/orbos/pkg/secret"
-	"github.com/caos/zitadel/operator/database/kinds/databases/managed/certificate"
-
 	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/kubernetes/resources/pdb"
+	"github.com/caos/orbos/pkg/labels"
+	"github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/tree"
+
+	"github.com/caos/zitadel/operator"
+	"github.com/caos/zitadel/operator/common"
 	"github.com/caos/zitadel/operator/database/kinds/backups"
 	"github.com/caos/zitadel/operator/database/kinds/databases/core"
+	"github.com/caos/zitadel/operator/database/kinds/databases/managed/certificate"
 	"github.com/caos/zitadel/operator/database/kinds/databases/managed/rbac"
 	"github.com/caos/zitadel/operator/database/kinds/databases/managed/services"
 	"github.com/caos/zitadel/operator/database/kinds/databases/managed/statefulset"
-	"github.com/pkg/errors"
 )
 
 const (
@@ -35,7 +33,6 @@ const (
 	privateServiceName = SfsName
 	cockroachPort      = int32(26257)
 	cockroachHTTPPort  = int32(8080)
-	image              = "cockroachdb/cockroach:v20.2.3"
 )
 
 func Adapter(
@@ -54,28 +51,38 @@ func Adapter(
 		desired *tree.Tree,
 		current *tree.Tree,
 	) (
-		operator.QueryFunc,
-		operator.DestroyFunc,
-		operator.ConfigureFunc,
-		map[string]*secret.Secret,
-		map[string]*secret.Existing,
-		bool,
-		error,
+		_ operator.QueryFunc,
+		_ operator.DestroyFunc,
+		_ operator.ConfigureFunc,
+		_ map[string]*secret.Secret,
+		_ map[string]*secret.Existing,
+		migrate bool,
+		err error,
 	) {
 
+		defer func() {
+			if err != nil {
+				err = fmt.Errorf("adapting managed database failed: %w", err)
+			}
+		}()
+
 		var (
 			internalMonitor = monitor.WithField("kind", "cockroachdb")
 			allSecrets      = make(map[string]*secret.Secret)
 			allExisting     = make(map[string]*secret.Existing)
-			migrate         bool
 		)
 
 		desiredKind, err := parseDesiredV0(desired)
 		if err != nil {
-			return nil, nil, nil, nil, nil, false, errors.Wrap(err, "parsing desired state failed")
+			return nil, nil, nil, nil, nil, false, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		desired.Parsed = desiredKind
 
+		storageCapacity, err := resource.ParseQuantity(desiredKind.Spec.StorageCapacity)
+		if err != nil {
+			return nil, nil, nil, nil, nil, false, mntr.ToUserError(fmt.Errorf("parsing storage capacity format failed: %w", err))
+		}
+
 		if !monitor.IsVerbose() && desiredKind.Spec.Verbose {
 			internalMonitor.Verbose()
 		}
@@ -120,7 +127,7 @@ func Adapter(
 			common.CockroachImage.Reference(customImageRegistry),
 			serviceAccountName,
 			desiredKind.Spec.ReplicaCount,
-			desiredKind.Spec.StorageCapacity,
+			storageCapacity,
 			cockroachPort,
 			cockroachHTTPPort,
 			desiredKind.Spec.StorageClass,
@@ -148,10 +155,7 @@ func Adapter(
 		}
 
 		currentDB := &Current{
-			Common: &tree.Common{
-				Kind:    "databases.caos.ch/CockroachDB",
-				Version: "v0",
-			},
+			Common: tree.NewCommon("databases.caos.ch/CockroachDB", "v0", false),
 			Current: &CurrentDB{
 				CA: &certificate.Current{},
 			},

operator/database/kinds/databases/managed/adapt_backup_test.go

@@ -21,10 +21,7 @@ import (
 func getTreeWithDBAndBackup(t *testing.T, masterkey string, saJson string, backupName string) *tree.Tree {
 
 	bucketDesired := getDesiredTree(t, masterkey, &bucket.DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/BucketBackup",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/BucketBackup", "v0", false),
 		Spec: &bucket.Spec{
 			Verbose: true,
 			Cron:    "testCron",
@@ -39,10 +36,7 @@ func getTreeWithDBAndBackup(t *testing.T, masterkey string, saJson string, backu
 	bucketDesired.Parsed = bucketDesiredKind
 
 	return getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/CockroachDB",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/CockroachDB", "v0", false),
 		Spec: Spec{
 			Verbose:         false,
 			ReplicaCount:    1,

operator/database/kinds/databases/managed/adapt_test.go

@@ -74,10 +74,7 @@ func TestManaged_Adapt1(t *testing.T) {
 	queried := map[string]interface{}{}
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/CockroachDB",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/CockroachDB", "v0", false),
 		Spec: Spec{
 			Verbose:         false,
 			ReplicaCount:    1,
@@ -195,10 +192,7 @@ func TestManaged_Adapt2(t *testing.T) {
 	queried := map[string]interface{}{}
 
 	desired := getDesiredTree(t, masterkey, &DesiredV0{
-		Common: &tree.Common{
-			Kind:    "databases.caos.ch/CockroachDB",
-			Version: "v0",
-		},
+		Common: tree.NewCommon("databases.caos.ch/CockroachDB", "v0", false),
 		Spec: Spec{
 			Verbose:         false,
 			ReplicaCount:    1,

operator/database/kinds/databases/managed/desired.go

@@ -1,10 +1,13 @@
 package managed
 
 import (
+	"fmt"
+
+	corev1 "k8s.io/api/core/v1"
+
+	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes/k8s"
 	"github.com/caos/orbos/pkg/tree"
-	"github.com/pkg/errors"
-	corev1 "k8s.io/api/core/v1"
 )
 
 type DesiredV0 struct {
@@ -32,7 +35,7 @@ func parseDesiredV0(desiredTree *tree.Tree) (*DesiredV0, error) {
 	}
 
 	if err := desiredTree.Original.Decode(desiredKind); err != nil {
-		return nil, errors.Wrap(err, "parsing desired state failed")
+		return nil, mntr.ToUserError(fmt.Errorf("parsing desired state failed"))
 	}
 
 	return desiredKind, nil

operator/database/kinds/databases/managed/listbackups.go

@@ -1,18 +1,20 @@
 package managed
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/tree"
+
 	"github.com/caos/zitadel/operator/database/kinds/backups"
-	"github.com/pkg/errors"
 )
 
 func BackupList() func(monitor mntr.Monitor, k8sClient kubernetes.ClientInt, desired *tree.Tree) ([]string, error) {
 	return func(monitor mntr.Monitor, k8sClient kubernetes.ClientInt, desired *tree.Tree) ([]string, error) {
 		desiredKind, err := parseDesiredV0(desired)
 		if err != nil {
-			return nil, errors.Wrap(err, "parsing desired state failed")
+			return nil, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		desired.Parsed = desiredKind
 

operator/database/kinds/databases/managed/statefulset/adapt.go

@@ -1,14 +1,16 @@
 package statefulset
 
 import (
+	"errors"
 	"fmt"
 	"sort"
 	"strings"
 	"time"
 
-	"github.com/caos/orbos/pkg/labels"
-	"github.com/caos/zitadel/operator"
-	"github.com/caos/zitadel/operator/helpers"
+	appsv1 "k8s.io/api/apps/v1"
+	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
 
 	"github.com/caos/orbos/mntr"
@@ -16,11 +18,10 @@ import (
 	"github.com/caos/orbos/pkg/kubernetes/k8s"
 	"github.com/caos/orbos/pkg/kubernetes/resources"
 	"github.com/caos/orbos/pkg/kubernetes/resources/statefulset"
-	"github.com/pkg/errors"
-	appsv1 "k8s.io/api/apps/v1"
-	corev1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/api/resource"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"github.com/caos/orbos/pkg/labels"
+
+	"github.com/caos/zitadel/operator"
+	"github.com/caos/zitadel/operator/helpers"
 )
 
 const (
@@ -55,7 +56,7 @@ func AdaptFunc(
 	image string,
 	serviceAccountName string,
 	replicaCount int,
-	storageCapacity string,
+	storageCapacity resource.Quantity,
 	dbPort int32,
 	httpPort int32,
 	storageClass string,
@@ -72,11 +73,6 @@ func AdaptFunc(
 ) {
 	internalMonitor := monitor.WithField("component", "statefulset")
 
-	quantity, err := resource.ParseQuantity(storageCapacity)
-	if err != nil {
-		return nil, nil, nil, nil, nil, err
-	}
-
 	name := sfsSelectable.Name()
 	k8sSelectable := labels.MustK8sMap(sfsSelectable)
 	statefulsetDef := &appsv1.StatefulSet{
@@ -197,7 +193,7 @@ func AdaptFunc(
 					},
 					Resources: corev1.ResourceRequirements{
 						Requests: corev1.ResourceList{
-							"storage": quantity,
+							"storage": storageCapacity,
 						},
 					},
 					StorageClassName: &storageClass,
@@ -219,8 +215,7 @@ func AdaptFunc(
 	checkDBRunning := func(k8sClient kubernetes.ClientInt) error {
 		internalMonitor.Info("waiting for statefulset to be running")
 		if err := k8sClient.WaitUntilStatefulsetIsReady(namespace, name, true, false, 60*time.Second); err != nil {
-			internalMonitor.Error(errors.Wrap(err, "error while waiting for statefulset to be running"))
-			return err
+			return fmt.Errorf("error while waiting for statefulset to be running: %w", err)
 		}
 		internalMonitor.Info("statefulset is running")
 		return nil
@@ -232,7 +227,6 @@ func AdaptFunc(
 			internalMonitor.Info("statefulset is not ready")
 			return nil
 		}
-		internalMonitor.Info("statefulset is ready")
 		return errors.New("statefulset is ready")
 	}
 
@@ -256,8 +250,7 @@ func AdaptFunc(
 	checkDBReady := func(k8sClient kubernetes.ClientInt) error {
 		internalMonitor.Info("waiting for statefulset to be ready")
 		if err := k8sClient.WaitUntilStatefulsetIsReady(namespace, name, true, true, 60*time.Second); err != nil {
-			internalMonitor.Error(errors.Wrap(err, "error while waiting for statefulset to be ready"))
-			return err
+			return fmt.Errorf("error while waiting for statefulset to be ready: %w", err)
 		}
 		internalMonitor.Info("statefulset is ready")
 		return nil

operator/database/kinds/databases/managed/statefulset/adapt_test.go

@@ -1,6 +1,8 @@
 package statefulset
 
 import (
+	"testing"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes/k8s"
 	kubernetesmock "github.com/caos/orbos/pkg/kubernetes/mock"
@@ -13,7 +15,6 @@ import (
 	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/intstr"
-	"testing"
 )
 
 func TestStatefulset_JoinExec0(t *testing.T) {
@@ -291,7 +292,7 @@ func TestStatefulset_Adapt1(t *testing.T) {
 		image,
 		serviceAccountName,
 		replicaCount,
-		storageCapacity,
+		resource.MustParse(storageCapacity),
 		dbPort,
 		httpPort,
 		storageClass,
@@ -487,7 +488,7 @@ func TestStatefulset_Adapt2(t *testing.T) {
 		image,
 		serviceAccountName,
 		replicaCount,
-		storageCapacity,
+		resource.MustParse(storageCapacity),
 		dbPort,
 		httpPort,
 		storageClass,

operator/database/kinds/databases/provided/adapt.go

@@ -1,12 +1,14 @@
 package provided
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/tree"
+
 	"github.com/caos/zitadel/operator"
-	"github.com/pkg/errors"
 )
 
 func Adapter() operator.AdaptFunc {
@@ -25,15 +27,12 @@ func Adapter() operator.AdaptFunc {
 	) {
 		desiredKind, err := parseDesiredV0(desired)
 		if err != nil {
-			return nil, nil, nil, nil, nil, false, errors.Wrap(err, "parsing desired state failed")
+			return nil, nil, nil, nil, nil, false, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		desired.Parsed = desiredKind
 
 		currentDB := &Current{
-			Common: &tree.Common{
-				Kind:    "databases.caos.ch/ProvidedDatabase",
-				Version: "v0",
-			},
+			Common: tree.NewCommon("databases.caos.ch/ProvidedDatabase", "v0", false),
 		}
 		current.Parsed = currentDB
 

operator/database/kinds/databases/provided/desired.go

@@ -1,8 +1,10 @@
 package provided
 
 import (
+	"fmt"
+
+	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/tree"
-	"github.com/pkg/errors"
 )
 
 type DesiredV0 struct {
@@ -25,7 +27,7 @@ func parseDesiredV0(desiredTree *tree.Tree) (*DesiredV0, error) {
 	}
 
 	if err := desiredTree.Original.Decode(desiredKind); err != nil {
-		return nil, errors.Wrap(err, "parsing desired state failed")
+		return nil, mntr.ToUserError(fmt.Errorf("parsing desired state failed: %w", err))
 	}
 
 	return desiredKind, nil

operator/database/kinds/orb/adapt.go

@@ -1,6 +1,8 @@
 package orb
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/kubernetes/resources/namespace"
@@ -8,12 +10,12 @@ import (
 	"github.com/caos/orbos/pkg/secret"
 	"github.com/caos/orbos/pkg/tree"
 	"github.com/caos/orbos/pkg/treelabels"
+
 	"github.com/caos/zitadel/operator"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket/backup"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket/clean"
 	"github.com/caos/zitadel/operator/database/kinds/backups/bucket/restore"
 	"github.com/caos/zitadel/operator/database/kinds/databases"
-	"github.com/pkg/errors"
 )
 
 const (
@@ -45,14 +47,16 @@ func AdaptFunc(
 		err error,
 	) {
 		defer func() {
-			err = errors.Wrapf(err, "building %s failed", orbDesiredTree.Common.Kind)
+			if err != nil {
+				err = fmt.Errorf("building %s failed: %w", orbDesiredTree.Common.Kind, err)
+			}
 		}()
 
 		orbMonitor := monitor.WithField("kind", "orb")
 
 		desiredKind, err := ParseDesiredV0(orbDesiredTree)
 		if err != nil {
-			return nil, nil, nil, nil, nil, migrate, errors.Wrap(err, "parsing desired state failed")
+			return nil, nil, nil, nil, nil, migrate, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		orbDesiredTree.Parsed = desiredKind
 		currentTree = &tree.Tree{}
@@ -118,10 +122,7 @@ func AdaptFunc(
 		}
 
 		currentTree.Parsed = &DesiredV0{
-			Common: &tree.Common{
-				Kind:    "databases.caos.ch/Orb",
-				Version: "v0",
-			},
+			Common:   tree.NewCommon("databases.caos.ch/Orb", "v0", false),
 			Database: databaseCurrent,
 		}
 

operator/database/kinds/orb/backups.go

@@ -1,18 +1,20 @@
 package orb
 
 import (
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/tree"
+
 	"github.com/caos/zitadel/operator/database/kinds/databases"
-	"github.com/pkg/errors"
 )
 
 func BackupListFunc() func(monitor mntr.Monitor, k8sClient kubernetes.ClientInt, desiredTree *tree.Tree) (strings []string, err error) {
 	return func(monitor mntr.Monitor, k8sClient kubernetes.ClientInt, desiredTree *tree.Tree) (strings []string, err error) {
 		desiredKind, err := ParseDesiredV0(desiredTree)
 		if err != nil {
-			return nil, errors.Wrap(err, "parsing desired state failed")
+			return nil, fmt.Errorf("parsing desired state failed: %w", err)
 		}
 		desiredTree.Parsed = desiredKind
 

operator/database/kinds/orb/desired.go

@@ -1,8 +1,10 @@
 package orb
 
 import (
+	"fmt"
+
+	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/tree"
-	"github.com/pkg/errors"
 	corev1 "k8s.io/api/core/v1"
 )
 
@@ -28,9 +30,9 @@ func ParseDesiredV0(desiredTree *tree.Tree) (*DesiredV0, error) {
 	desiredKind := &DesiredV0{Common: desiredTree.Common}
 
 	if err := desiredTree.Original.Decode(desiredKind); err != nil {
-		return nil, errors.Wrap(err, "parsing desired state failed")
+		return nil, mntr.ToUserError(fmt.Errorf("parsing desired state failed: %w", err))
 	}
-	desiredKind.Common.Version = "v0"
+	desiredKind.Common.OverwriteVersion("v0")
 
 	return desiredKind, nil
 }

operator/database/kinds/orb/reconcile.go

@@ -1,14 +1,17 @@
 package orb
 
 import (
+	"errors"
+	"fmt"
+
 	"github.com/caos/orbos/mntr"
 	"github.com/caos/orbos/pkg/kubernetes"
 	"github.com/caos/orbos/pkg/labels"
 	"github.com/caos/orbos/pkg/tree"
 	"github.com/caos/orbos/pkg/treelabels"
+
 	"github.com/caos/zitadel/operator"
 	zitadelKubernetes "github.com/caos/zitadel/pkg/kubernetes"
-	"github.com/pkg/errors"
 )
 
 func Reconcile(
@@ -23,29 +26,23 @@ func Reconcile(
 			recMonitor := monitor.WithField("version", spec.Version)
 
 			if spec.Version == "" {
-				err := errors.New("No version provided for self-reconciling")
-				return err
+				return errors.New("no version provided for self-reconciling")
 			}
 
 			if spec.SelfReconciling {
 				desiredTree := &tree.Tree{
-					Common: &tree.Common{
-						Kind:    "databases.caos.ch/Orb",
-						Version: "v0",
-					},
+					Common: tree.NewCommon("databases.caos.ch/Orb", "v0", false),
 				}
 
 				if err := zitadelKubernetes.EnsureDatabaseArtifacts(monitor, treelabels.MustForAPI(desiredTree, mustDatabaseOperator(&spec.Version)), k8sClient, spec.Version, spec.NodeSelector, spec.Tolerations, spec.CustomImageRegistry, gitops); err != nil {
-					recMonitor.Error(errors.Wrap(err, "Failed to deploy database-operator into k8s-cluster"))
-					return err
+					return fmt.Errorf("failed to deploy database-operator into k8s-cluster: %w", err)
 				}
 				recMonitor.Info("Applied database-operator")
 			}
 			return nil
 		}, func(k8sClient kubernetes.ClientInt) error {
 			if err := zitadelKubernetes.DestroyDatabaseOperator(monitor, labels.MustForAPI(labels.NoopOperator("database-operator"), "database", "v0"), k8sClient, gitops); err != nil {
-				monitor.Error(errors.Wrap(err, "Failed to destroy database-operator in k8s-cluster"))
-				return err
+				return fmt.Errorf("failed to destroy database-operator in k8s-cluster: %w", err)
 			}
 			monitor.Info("Destroyed database-operator")
 			return nil