fix(lint) configure linter after update, fix linting issues

cgoetz-inovex · cgoetz-inovex · commit 18a9f06d5c6a · 2026-03-30T10:39:48.000+02:00
diff --git a/golang-ci.yaml b/golang-ci.yaml
@@ -47,6 +47,7 @@ linters:
     gosec:
       excludes:
         # Suppressions: (see https://github.com/securego/gosec#available-rules for details)
+        - G101 # "Look for hardcoded credentials" -> a lot of false positives in descriptions for resources like mariadb/credential
         - G104 # "Audit errors not checked" -> which we don't need and is a badly implemented version of errcheck
         - G102 # "Bind to all interfaces" -> since this is normal in k8s
         - G304 # "File path provided as taint input" -> too many false positives
@@ -73,13 +74,27 @@ linters:
         - name: atomic
         - name: empty-lines
         - name: early-return
+    staticcheck:
+      checks:
+        # default from https://golangci-lint.run/docs/linters/configuration/#staticcheck
+        - all
+        - "-ST1000"
+        - "-ST1003"
+        - "-ST1016"
+        - "-ST1020"
+        - "-ST1021"
+        - "-ST1022"
+        # customizations
+        - "-SA1019" # disable deprecation errors while we switch over to the SDK structure with multi API version support
+        - "-QF1001" # disable 'could apply De Morgan's law': readability of boolean expressions is subjective and should be decided on a case-by-case basis
+        - "-QF1012" # disable 'use fmt.Fprintf instead' Fprintf returns bytes written and an error, which we'd have to handle/ignore to appease some other linter
   exclusions:
     generated: lax
     rules:
-      # disable deprecation errors while we switch over to the SDK structure with multi API version support
       - linters:
-          - staticcheck
-        text: 'SA1019:'
+          - gocritic
+        text: 'dupOption'
+        path: _acc_test\.go
     paths:
       - third_party$
       - builtin$
diff --git a/stackit/internal/services/authorization/roleassignments/resource.go b/stackit/internal/services/authorization/roleassignments/resource.go
@@ -70,7 +70,7 @@ type roleAssignmentResource struct {
 
 // Metadata returns the resource type name.
 func (r *roleAssignmentResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
-	resp.TypeName = fmt.Sprintf("%s_authorization_%s_role_assignment", req.ProviderTypeName, strings.Replace(r.apiName, "-", "_", -1))
+	resp.TypeName = fmt.Sprintf("%s_authorization_%s_role_assignment", req.ProviderTypeName, strings.ReplaceAll(r.apiName, "-", "_"))
 }
 
 // Configure adds the provider configured client to the resource.
diff --git a/stackit/internal/services/authorization/utils/util_test.go b/stackit/internal/services/authorization/utils/util_test.go
@@ -172,7 +172,6 @@ func TestLockAssignment(t *testing.T) {
 		// Wait a tiny bit to ensure G1 has started and acquired the lock
 		time.Sleep(10 * time.Millisecond)
 		wg.Go(func() {
-
 			// This should block until G1 releases the lock
 			unlock := LockAssignment(key)
 			defer unlock()
diff --git a/stackit/internal/services/cdn/distribution/resource.go b/stackit/internal/services/cdn/distribution/resource.go
@@ -570,7 +570,8 @@ func (r *distributionResource) Update(ctx context.Context, req resource.UpdateRe
 
 	configPatchBackend := &cdn.ConfigPatchBackend{}
 
-	if configModel.Backend.Type == "http" {
+	switch configModel.Backend.Type {
+	case "http":
 		geofencingPatch := map[string][]string{}
 		if configModel.Backend.Geofencing != nil {
 			gf := make(map[string][]string)
@@ -594,7 +595,7 @@ func (r *distributionResource) Update(ctx context.Context, req resource.UpdateRe
 			Type:                 new("http"),
 			Geofencing:           &geofencingPatch,
 		}
-	} else if configModel.Backend.Type == "bucket" {
+	case "bucket":
 		configPatchBackend.BucketBackendPatch = &cdn.BucketBackendPatch{
 			Type:      new("bucket"),
 			BucketUrl: configModel.Backend.BucketURL,
@@ -713,23 +714,23 @@ func mapFields(ctx context.Context, distribution *cdn.Distribution, model *Model
 	}
 
 	if distribution.ProjectId == nil {
-		return fmt.Errorf("Project ID not present")
+		return fmt.Errorf("'Project ID' not present")
 	}
 
 	if distribution.Id == nil {
 		return fmt.Errorf("CDN distribution ID not present")
 	}
 
 	if distribution.CreatedAt == nil {
-		return fmt.Errorf("CreatedAt missing in response")
+		return fmt.Errorf("'CreatedAt' missing in response")
 	}
 
 	if distribution.UpdatedAt == nil {
-		return fmt.Errorf("UpdatedAt missing in response")
+		return fmt.Errorf("'UpdatedAt' missing in response")
 	}
 
 	if distribution.Status == nil {
-		return fmt.Errorf("Status missing in response")
+		return fmt.Errorf("'Status' missing in response")
 	}
 
 	model.ID = utils.BuildInternalTerraformId(*distribution.ProjectId, *distribution.Id)
@@ -1083,7 +1084,8 @@ func convertConfig(ctx context.Context, model *Model) (*cdn.Config, error) {
 		BlockedCountries: &blockedCountries,
 	}
 
-	if configModel.Backend.Type == "http" {
+	switch configModel.Backend.Type {
+	case "http":
 		originRequestHeaders := map[string]string{}
 		if configModel.Backend.OriginRequestHeaders != nil {
 			maps.Copy(originRequestHeaders, *configModel.Backend.OriginRequestHeaders)
@@ -1094,7 +1096,7 @@ func convertConfig(ctx context.Context, model *Model) (*cdn.Config, error) {
 			Type:                 new("http"),
 			Geofencing:           &geofencing,
 		}
-	} else if configModel.Backend.Type == "bucket" {
+	case "bucket":
 		cdnConfig.Backend.BucketBackend = &cdn.BucketBackend{
 			Type:      new("bucket"),
 			BucketUrl: configModel.Backend.BucketURL,
diff --git a/stackit/internal/services/iaas/networkarea/resource_test.go b/stackit/internal/services/iaas/networkarea/resource_test.go
@@ -1086,9 +1086,10 @@ func TestUpdateNetworkRanges(t *testing.T) {
 			// Setup server and client
 			router := mux.NewRouter()
 			router.HandleFunc("/v2/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/network-ranges", func(w http.ResponseWriter, r *http.Request) {
-				if r.Method == "GET" {
+				switch r.Method {
+				case http.MethodGet:
 					getAllNetworkRangesHandler(w, r)
-				} else if r.Method == "POST" {
+				case http.MethodPost:
 					createNetworkRangeHandler(w, r)
 				}
 			})
diff --git a/stackit/internal/services/iaas/networkarearegion/resource_test.go b/stackit/internal/services/iaas/networkarearegion/resource_test.go
@@ -905,9 +905,10 @@ func Test_updateIpv4NetworkRanges(t *testing.T) {
 			// Setup server and client
 			router := mux.NewRouter()
 			router.HandleFunc("/v2/organizations/{organizationId}/network-areas/{areaId}/regions/{region}/network-ranges", func(w http.ResponseWriter, r *http.Request) {
-				if r.Method == "GET" {
+				switch r.Method {
+				case http.MethodGet:
 					getAllNetworkRangesHandler(w, r)
-				} else if r.Method == "POST" {
+				case http.MethodPost:
 					createNetworkRangeHandler(w, r)
 				}
 			})
diff --git a/stackit/internal/services/iaas/server/resource.go b/stackit/internal/services/iaas/server/resource.go
@@ -711,7 +711,7 @@ func (r *serverResource) updateServerAttributes(ctx context.Context, model, stat
 	// Generate API request body from model
 	payload, err := toUpdatePayload(ctx, model, stateModel.Labels)
 	if err != nil {
-		return nil, fmt.Errorf("Creating API payload: %w", err)
+		return nil, fmt.Errorf("creating API payload: %w", err)
 	}
 	projectId := model.ProjectId.ValueString()
 	serverId := model.ServerId.ValueString()
@@ -720,7 +720,7 @@ func (r *serverResource) updateServerAttributes(ctx context.Context, model, stat
 	// Update existing server
 	updatedServer, err = r.client.UpdateServer(ctx, projectId, region, serverId).UpdateServerPayload(*payload).Execute()
 	if err != nil {
-		return nil, fmt.Errorf("Calling API: %w", err)
+		return nil, fmt.Errorf("calling API: %w", err)
 	}
 
 	// Update machine type
@@ -731,7 +731,7 @@ func (r *serverResource) updateServerAttributes(ctx context.Context, model, stat
 		}
 		err := r.client.ResizeServer(ctx, projectId, region, serverId).ResizeServerPayload(payload).Execute()
 		if err != nil {
-			return nil, fmt.Errorf("Resizing the server, calling API: %w", err)
+			return nil, fmt.Errorf("resizing the server, calling API: %w", err)
 		}
 
 		_, err = wait.ResizeServerWaitHandler(ctx, r.client, projectId, region, serverId).WaitWithContext(ctx)
diff --git a/stackit/internal/services/iaas/volume/datasource.go b/stackit/internal/services/iaas/volume/datasource.go
@@ -226,7 +226,7 @@ func mapDatasourceFields(ctx context.Context, volumeResp *iaas.Volume, model *Da
 	} else if volumeResp.Id != nil {
 		volumeId = *volumeResp.Id
 	} else {
-		return fmt.Errorf("Volume id not present")
+		return fmt.Errorf("volume id not present")
 	}
 
 	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, volumeId)
diff --git a/stackit/internal/services/iaas/volume/resource.go b/stackit/internal/services/iaas/volume/resource.go
@@ -694,7 +694,7 @@ func mapFields(ctx context.Context, volumeResp *iaas.Volume, model *Model, regio
 	} else if volumeResp.Id != nil {
 		volumeId = *volumeResp.Id
 	} else {
-		return fmt.Errorf("Volume id not present")
+		return fmt.Errorf("volume id not present")
 	}
 
 	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, volumeId)
diff --git a/stackit/internal/services/observability/instance/resource.go b/stackit/internal/services/observability/instance/resource.go
@@ -2540,30 +2540,30 @@ func (r *instanceResource) getAlertConfigs(ctx context.Context, alertConfig *ale
 	if utils.IsUndefined(model.AlertConfig) {
 		*alertConfig, err = getMockAlertConfig(ctx)
 		if err != nil {
-			return fmt.Errorf("Getting mock alert config: %w", err)
+			return fmt.Errorf("getting mock alert config: %w", err)
 		}
 	}
 
 	alertConfigPayload, err := toUpdateAlertConfigPayload(ctx, alertConfig)
 	if err != nil {
-		return fmt.Errorf("Building alert config payload: %w", err)
+		return fmt.Errorf("building alert config payload: %w", err)
 	}
 
 	if alertConfigPayload != nil {
 		_, err = r.client.UpdateAlertConfigs(ctx, instanceId, projectId).UpdateAlertConfigsPayload(*alertConfigPayload).Execute()
 		if err != nil {
-			return fmt.Errorf("Setting alert config: %w", err)
+			return fmt.Errorf("setting alert config: %w", err)
 		}
 	}
 
 	alertConfigResp, err := r.client.GetAlertConfigs(ctx, instanceId, projectId).Execute()
 	if err != nil {
-		return fmt.Errorf("Calling API to get alert config: %w", err)
+		return fmt.Errorf("calling API to get alert config: %w", err)
 	}
 	// Map response body to schema
 	err = mapAlertConfigField(ctx, alertConfigResp, model)
 	if err != nil {
-		return fmt.Errorf("Processing API response for the alert config: %w", err)
+		return fmt.Errorf("processing API response for the alert config: %w", err)
 	}
 	return nil
 }
@@ -2576,7 +2576,7 @@ func (r *instanceResource) getTracesRetention(ctx context.Context, model *Model)
 	if tracesRetentionDays != nil {
 		tracesResp, err := r.client.GetTracesConfigs(ctx, instanceId, projectId).Execute()
 		if err != nil {
-			return fmt.Errorf("Getting traces retention policy: %w", err)
+			return fmt.Errorf("getting traces retention policy: %w", err)
 		}
 		if tracesResp == nil {
 			return fmt.Errorf("nil response")
@@ -2585,18 +2585,18 @@ func (r *instanceResource) getTracesRetention(ctx context.Context, model *Model)
 		retentionDays := fmt.Sprintf("%dh", *tracesRetentionDays*24)
 		_, err = r.client.UpdateTracesConfigs(ctx, instanceId, projectId).UpdateTracesConfigsPayload(observability.UpdateTracesConfigsPayload{Retention: &retentionDays}).Execute()
 		if err != nil {
-			return fmt.Errorf("Setting traces retention policy: %w", err)
+			return fmt.Errorf("setting traces retention policy: %w", err)
 		}
 	}
 
 	tracesResp, err := r.client.GetTracesConfigsExecute(ctx, instanceId, projectId)
 	if err != nil {
-		return fmt.Errorf("Getting traces retention policy: %w", err)
+		return fmt.Errorf("getting traces retention policy: %w", err)
 	}
 
 	err = mapTracesRetentionField(tracesResp, model)
 	if err != nil {
-		return fmt.Errorf("Processing API response for the traces retention %w", err)
+		return fmt.Errorf("processing API response for the traces retention %w", err)
 	}
 
 	return nil
@@ -2610,7 +2610,7 @@ func (r *instanceResource) getLogsRetention(ctx context.Context, model *Model) e
 	if logsRetentionDays != nil {
 		logsResp, err := r.client.GetLogsConfigs(ctx, instanceId, projectId).Execute()
 		if err != nil {
-			return fmt.Errorf("Getting logs retention policy: %w", err)
+			return fmt.Errorf("getting logs retention policy: %w", err)
 		}
 		if logsResp == nil {
 			return fmt.Errorf("nil response")
@@ -2619,18 +2619,18 @@ func (r *instanceResource) getLogsRetention(ctx context.Context, model *Model) e
 		retentionDays := fmt.Sprintf("%dh", *logsRetentionDays*24)
 		_, err = r.client.UpdateLogsConfigs(ctx, instanceId, projectId).UpdateLogsConfigsPayload(observability.UpdateLogsConfigsPayload{Retention: &retentionDays}).Execute()
 		if err != nil {
-			return fmt.Errorf("Setting logs retention policy: %w", err)
+			return fmt.Errorf("setting logs retention policy: %w", err)
 		}
 	}
 
 	logsResp, err := r.client.GetLogsConfigsExecute(ctx, instanceId, projectId)
 	if err != nil {
-		return fmt.Errorf("Getting logs retention policy: %w", err)
+		return fmt.Errorf("getting logs retention policy: %w", err)
 	}
 
 	err = mapLogsRetentionField(logsResp, model)
 	if err != nil {
-		return fmt.Errorf("Processing API response for the logs retention %w", err)
+		return fmt.Errorf("processing API response for the logs retention %w", err)
 	}
 
 	return nil
@@ -2648,29 +2648,29 @@ func (r *instanceResource) getMetricsRetention(ctx context.Context, model *Model
 		// Need to get the metrics retention policy because update endpoint is a PUT and we need to send all fields
 		metricsResp, err := r.client.GetMetricsStorageRetentionExecute(ctx, instanceId, projectId)
 		if err != nil {
-			return fmt.Errorf("Getting metrics retention policy: %w", err)
+			return fmt.Errorf("getting metrics retention policy: %w", err)
 		}
 
 		metricsRetentionPayload, err := toUpdateMetricsStorageRetentionPayload(metricsRetentionDays, metricsRetentionDays5mDownsampling, metricsRetentionDays1hDownsampling, metricsResp)
 		if err != nil {
-			return fmt.Errorf("Building metrics retention policy payload: %w", err)
+			return fmt.Errorf("building metrics retention policy payload: %w", err)
 		}
 		_, err = r.client.UpdateMetricsStorageRetention(ctx, instanceId, projectId).UpdateMetricsStorageRetentionPayload(*metricsRetentionPayload).Execute()
 		if err != nil {
-			return fmt.Errorf("Setting metrics retention policy: %w", err)
+			return fmt.Errorf("setting metrics retention policy: %w", err)
 		}
 	}
 
 	// Get metrics retention policy after update
 	metricsResp, err := r.client.GetMetricsStorageRetentionExecute(ctx, instanceId, projectId)
 	if err != nil {
-		return fmt.Errorf("Getting metrics retention policy: %w", err)
+		return fmt.Errorf("getting metrics retention policy: %w", err)
 	}
 
 	// Map response body to schema
 	err = mapMetricsRetentionField(metricsResp, model)
 	if err != nil {
-		return fmt.Errorf("Processing API response for the metrics retention %w", err)
+		return fmt.Errorf("processing API response for the metrics retention %w", err)
 	}
 	return nil
 }
diff --git a/stackit/internal/services/postgresflex/database/resource.go b/stackit/internal/services/postgresflex/database/resource.go
@@ -273,7 +273,7 @@ func (r *databaseResource) Read(ctx context.Context, req resource.ReadRequest, r
 	databaseResp, err := getDatabase(ctx, r.client, projectId, region, instanceId, databaseId)
 	if err != nil {
 		oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped
-		if (ok && oapiErr.StatusCode == http.StatusNotFound) || errors.Is(err, databaseNotFoundErr) {
+		if (ok && oapiErr.StatusCode == http.StatusNotFound) || errors.Is(err, errDatabaseNotFound) {
 			resp.State.RemoveResource(ctx)
 			return
 		}
@@ -418,7 +418,7 @@ func toCreatePayload(model *Model) (*postgresflex.CreateDatabasePayload, error)
 	}, nil
 }
 
-var databaseNotFoundErr = errors.New("database not found")
+var errDatabaseNotFound = errors.New("database not found")
 
 // The API does not have a GetDatabase endpoint, only ListDatabases
 func getDatabase(ctx context.Context, client *postgresflex.APIClient, projectId, region, instanceId, databaseId string) (*postgresflex.InstanceDatabase, error) {
@@ -434,5 +434,5 @@ func getDatabase(ctx context.Context, client *postgresflex.APIClient, projectId,
 			return &database, nil
 		}
 	}
-	return nil, databaseNotFoundErr
+	return nil, errDatabaseNotFound
 }
diff --git a/stackit/internal/services/secretsmanager/instance/resource_test.go b/stackit/internal/services/secretsmanager/instance/resource_test.go
@@ -472,9 +472,10 @@ func TestUpdateACLs(t *testing.T) {
 			// Setup server and client
 			router := mux.NewRouter()
 			router.HandleFunc("/v1/projects/{projectId}/instances/{instanceId}/acls", func(w http.ResponseWriter, r *http.Request) {
-				if r.Method == "GET" {
+				switch r.Method {
+				case http.MethodGet:
 					getAllACLsHandler(w, r)
-				} else if r.Method == "POST" {
+				case http.MethodPost:
 					createACLHandler(w, r)
 				}
 			})
diff --git a/stackit/internal/services/serverbackup/schedule/resource.go b/stackit/internal/services/serverbackup/schedule/resource.go
@@ -512,6 +512,7 @@ func mapFields(ctx context.Context, schedule *serverbackup.BackupSchedule, model
 }
 
 // If already enabled, just continues
+
 // Deprecated: This function will be removed on 26.09.2026. Use `server_backup_enable` resource instead.
 func (r *scheduleResource) enableBackupsService(ctx context.Context, model *Model) error {
 	projectId := model.ProjectId.ValueString()
@@ -534,6 +535,7 @@ func (r *scheduleResource) enableBackupsService(ctx context.Context, model *Mode
 }
 
 // Disables only if no backup schedules are present and no backups are present
+
 // Deprecated: This function will be removed on 26.09.2026. Use `server_backup_enable` resource instead.
 func (r *scheduleResource) disableBackupsService(ctx context.Context, model *Model) error {
 	tflog.Debug(ctx, "Disabling server backup service (in case there are no backups and no backup schedules)")
@@ -547,7 +549,7 @@ func (r *scheduleResource) disableBackupsService(ctx context.Context, model *Mod
 	if err != nil {
 		return fmt.Errorf("list backups: %w", err)
 	}
-	if *backups.Items != nil && len(*backups.Items) > 0 {
+	if len(*backups.Items) > 0 {
 		tflog.Debug(ctx, "Backups found - will not disable server backup service")
 		return nil
 	}
diff --git a/stackit/internal/services/sfs/resourcepool/resource.go b/stackit/internal/services/sfs/resourcepool/resource.go
diff --git a/stackit/internal/services/sfs/share/resource.go b/stackit/internal/services/sfs/share/resource.go
diff --git a/stackit/internal/services/ske/cluster/resource.go b/stackit/internal/services/ske/cluster/resource.go

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ type roleAssignmentResource struct {`
`70`	`70`
`71`	`71`	`// Metadata returns the resource type name.`
`72`	`72`	`func (r roleAssignmentResource) Metadata(_ context.Context, req resource.MetadataRequest, resp resource.MetadataResponse) {`
`73`		`- resp.TypeName = fmt.Sprintf("%s_authorization_%s_role_assignment", req.ProviderTypeName, strings.Replace(r.apiName, "-", "_", -1))`
	`73`	`+ resp.TypeName = fmt.Sprintf("%s_authorization_%s_role_assignment", req.ProviderTypeName, strings.ReplaceAll(r.apiName, "-", "_"))`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`// Configure adds the provider configured client to the resource.`
Original file line number	Diff line number	Diff line change
`@@ -711,7 +711,7 @@ func (r *serverResource) updateServerAttributes(ctx context.Context, model, stat`
`711`	`711`	`// Generate API request body from model`
`712`	`712`	`payload, err := toUpdatePayload(ctx, model, stateModel.Labels)`
`713`	`713`	`if err != nil {`
`714`		`- return nil, fmt.Errorf("Creating API payload: %w", err)`
	`714`	`+ return nil, fmt.Errorf("creating API payload: %w", err)`
`715`	`715`	`}`
`716`	`716`	`projectId := model.ProjectId.ValueString()`
`717`	`717`	`serverId := model.ServerId.ValueString()`
`@@ -720,7 +720,7 @@ func (r *serverResource) updateServerAttributes(ctx context.Context, model, stat`
`720`	`720`	`// Update existing server`
`721`	`721`	`updatedServer, err = r.client.UpdateServer(ctx, projectId, region, serverId).UpdateServerPayload(*payload).Execute()`
`722`	`722`	`if err != nil {`
`723`		`- return nil, fmt.Errorf("Calling API: %w", err)`
	`723`	`+ return nil, fmt.Errorf("calling API: %w", err)`
`724`	`724`	`}`
`725`	`725`
`726`	`726`	`// Update machine type`
`@@ -731,7 +731,7 @@ func (r *serverResource) updateServerAttributes(ctx context.Context, model, stat`
`731`	`731`	`}`
`732`	`732`	`err := r.client.ResizeServer(ctx, projectId, region, serverId).ResizeServerPayload(payload).Execute()`
`733`	`733`	`if err != nil {`
`734`		`- return nil, fmt.Errorf("Resizing the server, calling API: %w", err)`
	`734`	`+ return nil, fmt.Errorf("resizing the server, calling API: %w", err)`
`735`	`735`	`}`
`736`	`736`
`737`	`737`	`_, err = wait.ResizeServerWaitHandler(ctx, r.client, projectId, region, serverId).WaitWithContext(ctx)`
Original file line number	Diff line number	Diff line change
`@@ -226,7 +226,7 @@ func mapDatasourceFields(ctx context.Context, volumeResp iaas.Volume, model Da`
`226`	`226`	`} else if volumeResp.Id != nil {`
`227`	`227`	`volumeId = *volumeResp.Id`
`228`	`228`	`} else {`
`229`		`- return fmt.Errorf("Volume id not present")`
	`229`	`+ return fmt.Errorf("volume id not present")`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, volumeId)`
Original file line number	Diff line number	Diff line change
`@@ -694,7 +694,7 @@ func mapFields(ctx context.Context, volumeResp iaas.Volume, model Model, regio`
`694`	`694`	`} else if volumeResp.Id != nil {`
`695`	`695`	`volumeId = *volumeResp.Id`
`696`	`696`	`} else {`
`697`		`- return fmt.Errorf("Volume id not present")`
	`697`	`+ return fmt.Errorf("volume id not present")`
`698`	`698`	`}`
`699`	`699`
`700`	`700`	`model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, volumeId)`
Original file line number	Diff line number	Diff line change
`@@ -2540,30 +2540,30 @@ func (r instanceResource) getAlertConfigs(ctx context.Context, alertConfig ale`
`2540`	`2540`	`if utils.IsUndefined(model.AlertConfig) {`
`2541`	`2541`	`*alertConfig, err = getMockAlertConfig(ctx)`
`2542`	`2542`	`if err != nil {`
`2543`		`- return fmt.Errorf("Getting mock alert config: %w", err)`
	`2543`	`+ return fmt.Errorf("getting mock alert config: %w", err)`
`2544`	`2544`	`}`
`2545`	`2545`	`}`
`2546`	`2546`
`2547`	`2547`	`alertConfigPayload, err := toUpdateAlertConfigPayload(ctx, alertConfig)`
`2548`	`2548`	`if err != nil {`
`2549`		`- return fmt.Errorf("Building alert config payload: %w", err)`
	`2549`	`+ return fmt.Errorf("building alert config payload: %w", err)`
`2550`	`2550`	`}`
`2551`	`2551`
`2552`	`2552`	`if alertConfigPayload != nil {`
`2553`	`2553`	`_, err = r.client.UpdateAlertConfigs(ctx, instanceId, projectId).UpdateAlertConfigsPayload(*alertConfigPayload).Execute()`
`2554`	`2554`	`if err != nil {`
`2555`		`- return fmt.Errorf("Setting alert config: %w", err)`
	`2555`	`+ return fmt.Errorf("setting alert config: %w", err)`
`2556`	`2556`	`}`
`2557`	`2557`	`}`
`2558`	`2558`
`2559`	`2559`	`alertConfigResp, err := r.client.GetAlertConfigs(ctx, instanceId, projectId).Execute()`
`2560`	`2560`	`if err != nil {`
`2561`		`- return fmt.Errorf("Calling API to get alert config: %w", err)`
	`2561`	`+ return fmt.Errorf("calling API to get alert config: %w", err)`
`2562`	`2562`	`}`
`2563`	`2563`	`// Map response body to schema`
`2564`	`2564`	`err = mapAlertConfigField(ctx, alertConfigResp, model)`
`2565`	`2565`	`if err != nil {`
`2566`		`- return fmt.Errorf("Processing API response for the alert config: %w", err)`
	`2566`	`+ return fmt.Errorf("processing API response for the alert config: %w", err)`
`2567`	`2567`	`}`
`2568`	`2568`	`return nil`
`2569`	`2569`	`}`
`@@ -2576,7 +2576,7 @@ func (r instanceResource) getTracesRetention(ctx context.Context, model Model)`
`2576`	`2576`	`if tracesRetentionDays != nil {`
`2577`	`2577`	`tracesResp, err := r.client.GetTracesConfigs(ctx, instanceId, projectId).Execute()`
`2578`	`2578`	`if err != nil {`
`2579`		`- return fmt.Errorf("Getting traces retention policy: %w", err)`
	`2579`	`+ return fmt.Errorf("getting traces retention policy: %w", err)`
`2580`	`2580`	`}`
`2581`	`2581`	`if tracesResp == nil {`
`2582`	`2582`	`return fmt.Errorf("nil response")`
`@@ -2585,18 +2585,18 @@ func (r instanceResource) getTracesRetention(ctx context.Context, model Model)`
`2585`	`2585`	`retentionDays := fmt.Sprintf("%dh", tracesRetentionDays24)`
`2586`	`2586`	`_, err = r.client.UpdateTracesConfigs(ctx, instanceId, projectId).UpdateTracesConfigsPayload(observability.UpdateTracesConfigsPayload{Retention: &retentionDays}).Execute()`
`2587`	`2587`	`if err != nil {`
`2588`		`- return fmt.Errorf("Setting traces retention policy: %w", err)`
	`2588`	`+ return fmt.Errorf("setting traces retention policy: %w", err)`
`2589`	`2589`	`}`
`2590`	`2590`	`}`
`2591`	`2591`
`2592`	`2592`	`tracesResp, err := r.client.GetTracesConfigsExecute(ctx, instanceId, projectId)`
`2593`	`2593`	`if err != nil {`
`2594`		`- return fmt.Errorf("Getting traces retention policy: %w", err)`
	`2594`	`+ return fmt.Errorf("getting traces retention policy: %w", err)`
`2595`	`2595`	`}`
`2596`	`2596`
`2597`	`2597`	`err = mapTracesRetentionField(tracesResp, model)`
`2598`	`2598`	`if err != nil {`
`2599`		`- return fmt.Errorf("Processing API response for the traces retention %w", err)`
	`2599`	`+ return fmt.Errorf("processing API response for the traces retention %w", err)`
`2600`	`2600`	`}`
`2601`	`2601`
`2602`	`2602`	`return nil`
`@@ -2610,7 +2610,7 @@ func (r instanceResource) getLogsRetention(ctx context.Context, model Model) e`
`2610`	`2610`	`if logsRetentionDays != nil {`
`2611`	`2611`	`logsResp, err := r.client.GetLogsConfigs(ctx, instanceId, projectId).Execute()`
`2612`	`2612`	`if err != nil {`
`2613`		`- return fmt.Errorf("Getting logs retention policy: %w", err)`
	`2613`	`+ return fmt.Errorf("getting logs retention policy: %w", err)`
`2614`	`2614`	`}`
`2615`	`2615`	`if logsResp == nil {`
`2616`	`2616`	`return fmt.Errorf("nil response")`
`@@ -2619,18 +2619,18 @@ func (r instanceResource) getLogsRetention(ctx context.Context, model Model) e`
`2619`	`2619`	`retentionDays := fmt.Sprintf("%dh", logsRetentionDays24)`
`2620`	`2620`	`_, err = r.client.UpdateLogsConfigs(ctx, instanceId, projectId).UpdateLogsConfigsPayload(observability.UpdateLogsConfigsPayload{Retention: &retentionDays}).Execute()`
`2621`	`2621`	`if err != nil {`
`2622`		`- return fmt.Errorf("Setting logs retention policy: %w", err)`
	`2622`	`+ return fmt.Errorf("setting logs retention policy: %w", err)`
`2623`	`2623`	`}`
`2624`	`2624`	`}`
`2625`	`2625`
`2626`	`2626`	`logsResp, err := r.client.GetLogsConfigsExecute(ctx, instanceId, projectId)`
`2627`	`2627`	`if err != nil {`
`2628`		`- return fmt.Errorf("Getting logs retention policy: %w", err)`
	`2628`	`+ return fmt.Errorf("getting logs retention policy: %w", err)`
`2629`	`2629`	`}`
`2630`	`2630`
`2631`	`2631`	`err = mapLogsRetentionField(logsResp, model)`
`2632`	`2632`	`if err != nil {`
`2633`		`- return fmt.Errorf("Processing API response for the logs retention %w", err)`
	`2633`	`+ return fmt.Errorf("processing API response for the logs retention %w", err)`
`2634`	`2634`	`}`
`2635`	`2635`
`2636`	`2636`	`return nil`
`@@ -2648,29 +2648,29 @@ func (r instanceResource) getMetricsRetention(ctx context.Context, model Model`
`2648`	`2648`	`// Need to get the metrics retention policy because update endpoint is a PUT and we need to send all fields`
`2649`	`2649`	`metricsResp, err := r.client.GetMetricsStorageRetentionExecute(ctx, instanceId, projectId)`
`2650`	`2650`	`if err != nil {`
`2651`		`- return fmt.Errorf("Getting metrics retention policy: %w", err)`
	`2651`	`+ return fmt.Errorf("getting metrics retention policy: %w", err)`
`2652`	`2652`	`}`
`2653`	`2653`
`2654`	`2654`	`metricsRetentionPayload, err := toUpdateMetricsStorageRetentionPayload(metricsRetentionDays, metricsRetentionDays5mDownsampling, metricsRetentionDays1hDownsampling, metricsResp)`
`2655`	`2655`	`if err != nil {`
`2656`		`- return fmt.Errorf("Building metrics retention policy payload: %w", err)`
	`2656`	`+ return fmt.Errorf("building metrics retention policy payload: %w", err)`
`2657`	`2657`	`}`
`2658`	`2658`	`_, err = r.client.UpdateMetricsStorageRetention(ctx, instanceId, projectId).UpdateMetricsStorageRetentionPayload(*metricsRetentionPayload).Execute()`
`2659`	`2659`	`if err != nil {`
`2660`		`- return fmt.Errorf("Setting metrics retention policy: %w", err)`
	`2660`	`+ return fmt.Errorf("setting metrics retention policy: %w", err)`
`2661`	`2661`	`}`
`2662`	`2662`	`}`
`2663`	`2663`
`2664`	`2664`	`// Get metrics retention policy after update`
`2665`	`2665`	`metricsResp, err := r.client.GetMetricsStorageRetentionExecute(ctx, instanceId, projectId)`
`2666`	`2666`	`if err != nil {`
`2667`		`- return fmt.Errorf("Getting metrics retention policy: %w", err)`
	`2667`	`+ return fmt.Errorf("getting metrics retention policy: %w", err)`
`2668`	`2668`	`}`
`2669`	`2669`
`2670`	`2670`	`// Map response body to schema`
`2671`	`2671`	`err = mapMetricsRetentionField(metricsResp, model)`
`2672`	`2672`	`if err != nil {`
`2673`		`- return fmt.Errorf("Processing API response for the metrics retention %w", err)`
	`2673`	`+ return fmt.Errorf("processing API response for the metrics retention %w", err)`
`2674`	`2674`	`}`
`2675`	`2675`	`return nil`
`2676`	`2676`	`}`