add sentry to grid deployer

Author: rawdaGastan

grid-client/deployer/deployment_deployer.go

@@ -31,20 +31,20 @@ func NewDeploymentDeployer(tfPluginClient *TFPluginClient) DeploymentDeployer {
 // Validate validates a deployment deployer
 func (d *DeploymentDeployer) Validate(ctx context.Context, dls []*workloads.Deployment) error {
 	if err := validateAccountBalanceForExtrinsics(d.tfPluginClient.SubstrateConn, d.tfPluginClient.Identity); err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	for _, dl := range dls {
 		if err := dl.Validate(); err != nil {
-			return err
+			return d.tfPluginClient.sentry.error(err)
 		}
 	}
 
 	return nil
 }
 
 // GenerateVersionlessDeployments generates a new deployment without a version
-func (d *DeploymentDeployer) GenerateVersionlessDeployments(ctx context.Context, dls []*workloads.Deployment) (map[uint32][]zos.Deployment, error) {
+func (d *DeploymentDeployer) generateVersionlessDeployments(ctx context.Context, dls []*workloads.Deployment) (map[uint32][]zos.Deployment, error) {
 	gridDlsPerNodes := make(map[uint32][]zos.Deployment)
 
 	var wg sync.WaitGroup
@@ -107,16 +107,16 @@ func (d *DeploymentDeployer) GenerateVersionlessDeployments(ctx context.Context,
 // Deploy deploys a new deployment
 func (d *DeploymentDeployer) Deploy(ctx context.Context, dl *workloads.Deployment) error {
 	if err := d.Validate(ctx, []*workloads.Deployment{dl}); err != nil {
-		return fmt.Errorf("invalid deployment: %w", err)
+		return d.tfPluginClient.sentry.error(fmt.Errorf("invalid deployment: %w", err))
 	}
 
-	dlsPerNodes, err := d.GenerateVersionlessDeployments(ctx, []*workloads.Deployment{dl})
+	dlsPerNodes, err := d.generateVersionlessDeployments(ctx, []*workloads.Deployment{dl})
 	if err != nil {
-		return errors.Wrap(err, "could not generate deployments data")
+		return d.tfPluginClient.sentry.error(errors.Wrap(err, "could not generate deployments data"))
 	}
 
 	if len(dlsPerNodes[dl.NodeID]) == 0 {
-		return fmt.Errorf("failed to generate the grid deployment")
+		return d.tfPluginClient.sentry.error(fmt.Errorf("failed to generate the grid deployment"))
 	}
 
 	dl.NodeDeploymentID, err = d.deployer.Deploy(
@@ -132,7 +132,7 @@ func (d *DeploymentDeployer) Deploy(ctx context.Context, dl *workloads.Deploymen
 		d.tfPluginClient.State.StoreContractIDs(dl.NodeID, dl.ContractID)
 	}
 
-	return err
+	return d.tfPluginClient.sentry.error(err)
 }
 
 // BatchDeploy deploys multiple deployments using the deployer
@@ -144,13 +144,13 @@ func (d *DeploymentDeployer) BatchDeploy(ctx context.Context, dls []*workloads.D
 		multiErr = multierror.Append(multiErr, fmt.Errorf("invalid deployments: %w", err))
 	}
 
-	newDeployments, err := d.GenerateVersionlessDeployments(ctx, dls)
+	newDeployments, err := d.generateVersionlessDeployments(ctx, dls)
 	if err != nil {
 		multiErr = multierror.Append(multiErr, fmt.Errorf("could not generate grid deployments: %w", err))
 	}
 
 	if len(newDeployments) == 0 {
-		return errors.Wrap(multiErr, "failed to generate the grid deployments")
+		return d.tfPluginClient.sentry.error(errors.Wrap(multiErr, "failed to generate the grid deployments"))
 	}
 
 	newDls, err := d.deployer.BatchDeploy(ctx, newDeployments, newDeploymentsSolutionProvider)
@@ -166,18 +166,18 @@ func (d *DeploymentDeployer) BatchDeploy(ctx context.Context, dls []*workloads.D
 		}
 	}
 
-	return multiErr
+	return d.tfPluginClient.sentry.error(multiErr)
 }
 
 // Cancel cancels deployments
 func (d *DeploymentDeployer) Cancel(ctx context.Context, dl *workloads.Deployment) error {
 	if err := d.Validate(ctx, []*workloads.Deployment{dl}); err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	err := d.deployer.Cancel(ctx, dl.ContractID)
 	if err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	// update state
@@ -374,11 +374,11 @@ func (d *DeploymentDeployer) syncContract(dl *workloads.Deployment) error {
 func (d *DeploymentDeployer) Sync(ctx context.Context, dl *workloads.Deployment) error {
 	err := d.syncContract(dl)
 	if err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 	currentDeployments, err := d.deployer.GetDeployments(ctx, dl.NodeDeploymentID)
 	if err != nil {
-		return errors.Wrap(err, "failed to get deployments to update local state")
+		return d.tfPluginClient.sentry.error(errors.Wrap(err, "failed to get deployments to update local state"))
 	}
 
 	deployment := currentDeployments[dl.NodeID]

grid-client/deployer/deployment_deployer_test.go

@@ -353,7 +353,7 @@ func TestDeploymentDeployerDeploy(t *testing.T) {
 				return nil
 			}).AnyTimes()
 
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), []*workloads.Deployment{&dl})
+		dls, err := d.generateVersionlessDeployments(context.Background(), []*workloads.Deployment{&dl})
 		assert.NoError(t, err)
 
 		assert.Equal(t, len(gridDl.Workloads), len(dls[dl.NodeID][0].Workloads))
@@ -528,7 +528,7 @@ func TestDeploymentDeployerSync(t *testing.T) {
 				return nil
 			})
 
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), []*workloads.Deployment{&dl})
+		dls, err := d.generateVersionlessDeployments(context.Background(), []*workloads.Deployment{&dl})
 		assert.NoError(t, err)
 
 		gridDl := dls[dl.NodeID][0]

grid-client/deployer/gateway_fqdn_deployer.go

@@ -30,32 +30,32 @@ func NewGatewayFqdnDeployer(tfPluginClient *TFPluginClient) GatewayFQDNDeployer
 func (d *GatewayFQDNDeployer) Validate(ctx context.Context, gw *workloads.GatewayFQDNProxy) error {
 	sub := d.tfPluginClient.SubstrateConn
 	if err := validateAccountBalanceForExtrinsics(sub, d.tfPluginClient.Identity); err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	if err := gw.Validate(); err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	nodeClient, err := d.tfPluginClient.NcPool.GetNodeClient(sub, gw.NodeID)
 	if err != nil {
-		return errors.Wrapf(err, "failed to get node client with ID %d", gw.NodeID)
+		return d.tfPluginClient.sentry.error(errors.Wrapf(err, "failed to get node client with ID %d", gw.NodeID))
 	}
 
 	cfg, err := nodeClient.NetworkGetPublicConfig(ctx)
 	if err != nil {
-		return errors.Wrapf(err, "couldn't get node %d public config", gw.NodeID)
+		return d.tfPluginClient.sentry.error(errors.Wrapf(err, "couldn't get node %d public config", gw.NodeID))
 	}
 
 	if cfg.IPv4.IP == nil {
-		return errors.Errorf("node %d doesn't contain a public IP in its public config", gw.NodeID)
+		return d.tfPluginClient.sentry.error(errors.Errorf("node %d doesn't contain a public IP in its public config", gw.NodeID))
 	}
 
-	return client.AreNodesUp(ctx, sub, []uint32{gw.NodeID}, d.tfPluginClient.NcPool)
+	return d.tfPluginClient.sentry.error(client.AreNodesUp(ctx, sub, []uint32{gw.NodeID}, d.tfPluginClient.NcPool))
 }
 
 // GenerateVersionlessDeployments generates deployments for gatewayFqdn deployer without versions
-func (d *GatewayFQDNDeployer) GenerateVersionlessDeployments(ctx context.Context, gw *workloads.GatewayFQDNProxy) (map[uint32]zosTypes.Deployment, error) {
+func (d *GatewayFQDNDeployer) generateVersionlessDeployments(ctx context.Context, gw *workloads.GatewayFQDNProxy) (map[uint32]zosTypes.Deployment, error) {
 	deployments := make(map[uint32]zosTypes.Deployment)
 	var err error
 
@@ -74,12 +74,12 @@ func (d *GatewayFQDNDeployer) GenerateVersionlessDeployments(ctx context.Context
 // Deploy deploys the GatewayFQDN deployments using the deployer
 func (d *GatewayFQDNDeployer) Deploy(ctx context.Context, gw *workloads.GatewayFQDNProxy) error {
 	if err := d.Validate(ctx, gw); err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
-	newDeployments, err := d.GenerateVersionlessDeployments(ctx, gw)
+	newDeployments, err := d.generateVersionlessDeployments(ctx, gw)
 	if err != nil {
-		return errors.Wrap(err, "could not generate deployments data")
+		return d.tfPluginClient.sentry.error(errors.Wrap(err, "could not generate deployments data"))
 	}
 
 	// TODO: solution providers
@@ -97,7 +97,7 @@ func (d *GatewayFQDNDeployer) Deploy(ctx context.Context, gw *workloads.GatewayF
 		}
 	}
 
-	return err
+	return d.tfPluginClient.sentry.error(err)
 }
 
 // BatchDeploy deploys multiple deployments using the deployer
@@ -107,12 +107,12 @@ func (d *GatewayFQDNDeployer) BatchDeploy(ctx context.Context, gws []*workloads.
 
 	for _, gw := range gws {
 		if err := d.Validate(ctx, gw); err != nil {
-			return err
+			return d.tfPluginClient.sentry.error(err)
 		}
 
-		dls, err := d.GenerateVersionlessDeployments(ctx, gw)
+		dls, err := d.generateVersionlessDeployments(ctx, gw)
 		if err != nil {
-			return errors.Wrap(err, "could not generate deployments data")
+			return d.tfPluginClient.sentry.error(errors.Wrap(err, "could not generate deployments data"))
 		}
 
 		for nodeID, dl := range dls {
@@ -133,23 +133,23 @@ func (d *GatewayFQDNDeployer) BatchDeploy(ctx context.Context, gws []*workloads.
 	// error is not returned immediately before updating state because of untracked failed deployments
 	for _, gw := range gws {
 		if err := d.updateStateFromDeployments(gw, newDls); err != nil {
-			return errors.Wrapf(err, "failed to update gateway fqdn '%s' state", gw.Name)
+			return d.tfPluginClient.sentry.error(errors.Wrapf(err, "failed to update gateway fqdn '%s' state", gw.Name))
 		}
 	}
 
-	return err
+	return d.tfPluginClient.sentry.error(err)
 }
 
 // Cancel cancels a gateway deployment
 func (d *GatewayFQDNDeployer) Cancel(ctx context.Context, gw *workloads.GatewayFQDNProxy) (err error) {
 	if err := d.Validate(ctx, gw); err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	contractID := gw.NodeDeploymentID[gw.NodeID]
 	err = d.deployer.Cancel(ctx, contractID)
 	if err != nil {
-		return err
+		return d.tfPluginClient.sentry.error(err)
 	}
 
 	// update state
@@ -198,12 +198,12 @@ func (d *GatewayFQDNDeployer) syncContracts(ctx context.Context, gw *workloads.G
 // Sync syncs the gateway deployments
 func (d *GatewayFQDNDeployer) Sync(ctx context.Context, gw *workloads.GatewayFQDNProxy) error {
 	if err := d.syncContracts(ctx, gw); err != nil {
-		return errors.Wrap(err, "could not sync contracts")
+		return d.tfPluginClient.sentry.error(errors.Wrap(err, "could not sync contracts"))
 	}
 
 	dls, err := d.deployer.GetDeployments(ctx, gw.NodeDeploymentID)
 	if err != nil {
-		return errors.Wrap(err, "could not get deployment objects")
+		return d.tfPluginClient.sentry.error(errors.Wrap(err, "could not get deployment objects"))
 	}
 
 	dl := dls[gw.NodeID]
@@ -225,7 +225,7 @@ func (d *GatewayFQDNDeployer) Sync(ctx context.Context, gw *workloads.GatewayFQD
 		gw.Network = gwWorkload.Network
 
 		if err != nil {
-			return err
+			return d.tfPluginClient.sentry.error(err)
 		}
 	}
 

grid-client/deployer/gateway_fqdn_deployer_test.go

@@ -126,7 +126,7 @@ func TestFQDNDeployer(t *testing.T) {
 	})
 
 	t.Run("test generate", func(t *testing.T) {
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), &gw)
+		dls, err := d.generateVersionlessDeployments(context.Background(), &gw)
 		assert.NoError(t, err)
 
 		testDl := workloads.NewGridDeployment(twinID, 0, []zosTypes.Workload{
@@ -151,7 +151,7 @@ func TestFQDNDeployer(t *testing.T) {
 	})
 
 	t.Run("test deploy", func(t *testing.T) {
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), &gw)
+		dls, err := d.generateVersionlessDeployments(context.Background(), &gw)
 		assert.NoError(t, err)
 
 		mockValidation(d.tfPluginClient.Identity, cl, sub, ncPool, proxyCl)
@@ -175,7 +175,7 @@ func TestFQDNDeployer(t *testing.T) {
 
 		gw.NodeDeploymentID = map[uint32]uint64{nodeID: contractID}
 
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), &gw)
+		dls, err := d.generateVersionlessDeployments(context.Background(), &gw)
 		assert.NoError(t, err)
 
 		mockValidation(d.tfPluginClient.Identity, cl, sub, ncPool, proxyCl)
@@ -198,7 +198,7 @@ func TestFQDNDeployer(t *testing.T) {
 
 		gw.NodeDeploymentID = map[uint32]uint64{nodeID: contractID}
 
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), &gw)
+		dls, err := d.generateVersionlessDeployments(context.Background(), &gw)
 		assert.NoError(t, err)
 
 		mockValidation(d.tfPluginClient.Identity, cl, sub, ncPool, proxyCl)
@@ -316,7 +316,7 @@ func TestFQDNDeployer(t *testing.T) {
 		gw.ContractID = contractID
 		gw.NodeDeploymentID = map[uint32]uint64{nodeID: contractID}
 
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), &gw)
+		dls, err := d.generateVersionlessDeployments(context.Background(), &gw)
 		assert.NoError(t, err)
 
 		dl := dls[nodeID]
@@ -346,7 +346,7 @@ func TestFQDNDeployer(t *testing.T) {
 		gw.ContractID = contractID
 		gw.NodeDeploymentID = map[uint32]uint64{nodeID: contractID}
 
-		dls, err := d.GenerateVersionlessDeployments(context.Background(), &gw)
+		dls, err := d.generateVersionlessDeployments(context.Background(), &gw)
 		assert.NoError(t, err)
 
 		dl := dls[nodeID]