diff --git a/ibm/service/vpc/data_source_ibm_is_share.go b/ibm/service/vpc/data_source_ibm_is_share.go
index cd15ea7a22..c5232ebeb5 100644
--- a/ibm/service/vpc/data_source_ibm_is_share.go
+++ b/ibm/service/vpc/data_source_ibm_is_share.go
@@ -597,7 +597,9 @@ func DataSourceIbmIsShare() *schema.Resource {
 func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	shareName := d.Get("name").(string)
@@ -610,8 +612,9 @@ func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, m
 
 		shareItem, response, err := vpcClient.GetShareWithContext(context, getShareOptions)
 		if err != nil {
-			log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-			return diag.FromErr(fmt.Errorf("[ERROR] GetShareWithContext failed %s\n%s", err, response))
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("GetShareWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share", "read")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		share = shareItem
 	} else if shareName != "" {
@@ -622,8 +625,9 @@ func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, m
 		}
 		shareCollection, response, err := vpcClient.ListSharesWithContext(context, listSharesOptions)
 		if err != nil {
-			log.Printf("[DEBUG] ListSharesWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListSharesWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share", "read")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		for _, sharesItem := range shareCollection.Shares {
 			if *sharesItem.Name == shareName {
@@ -632,32 +636,38 @@ func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, m
 			}
 		}
 		if share == nil {
-			return diag.FromErr(fmt.Errorf("[ERROR] Share with provided name %s not found", shareName))
+			return flex.TerraformErrorf(err, fmt.Sprintf("[ERROR] Share with provided name %s not found", shareName), "(Data) ibm_is_share", "read").GetDiag()
 		}
 	}
 
 	d.SetId(*share.ID)
 	if err = d.Set("created_at", share.CreatedAt.String()); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting created_at: %s", err))
+		err = fmt.Errorf("Error setting captured_at: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-captured_at").GetDiag()
 	}
 	if err = d.Set("crn", share.CRN); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting crn: %s", err))
+		err = fmt.Errorf("Error setting crn: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-crn").GetDiag()
 	}
 	if err = d.Set("encryption", share.Encryption); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting encryption: %s", err))
+		err = fmt.Errorf("Error setting encryption: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-encryption").GetDiag()
 	}
 
 	if share.EncryptionKey != nil {
 		err = d.Set("encryption_key", *share.EncryptionKey.CRN)
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting encryption_key %s", err))
+			err = fmt.Errorf("Error setting encryption_key: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-encryption_key").GetDiag()
 		}
 	}
 	if err = d.Set("href", share.Href); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting href: %s", err))
+		err = fmt.Errorf("Error setting href: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-href").GetDiag()
 	}
 	if err = d.Set("iops", share.Iops); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting iops: %s", err))
+		err = fmt.Errorf("Error setting iops: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-iops").GetDiag()
 	}
 	latest_syncs := []map[string]interface{}{}
 	if share.LatestSync != nil {
@@ -673,15 +683,18 @@ func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, m
 	if share.LatestJob != nil {
 		err = d.Set("latest_job", dataSourceShareFlattenLatestJob(*share.LatestJob))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting latest_job %s", err))
+			err = fmt.Errorf("Error setting latest_job: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-latest_job").GetDiag()
 		}
 	}
 
 	if err = d.Set("lifecycle_state", share.LifecycleState); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting lifecycle_state: %s", err))
+		err = fmt.Errorf("Error setting lifecycle_state: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-lifecycle_state").GetDiag()
 	}
 	if err = d.Set("name", share.Name); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting name: %s", err))
+		err = fmt.Errorf("Error setting name: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-name").GetDiag()
 	}
 	if share.AccessControlMode != nil {
 		d.Set("access_control_mode", *share.AccessControlMode)
@@ -715,66 +728,79 @@ func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, m
 	if share.Profile != nil {
 		err = d.Set("profile", *share.Profile.Name)
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting profile %s", err))
+			err = fmt.Errorf("Error setting profile: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-profile").GetDiag()
 		}
 	}
 
 	if share.ReplicaShare != nil {
 		err = d.Set("replica_share", dataSourceShareFlattenReplicaShare(*share.ReplicaShare))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting replica_share %s", err))
+			err = fmt.Errorf("Error setting replica_share: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-replica_share").GetDiag()
 		}
 	}
 	if err = d.Set("replication_cron_spec", share.ReplicationCronSpec); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting replication_cron_spec: %s", err))
+		err = fmt.Errorf("Error setting replication_cron_spec: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-replication_cron_spec").GetDiag()
 	}
 	if err = d.Set("replication_role", share.ReplicationRole); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting replication_role: %s", err))
+		err = fmt.Errorf("Error setting replication_role: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-replication_role").GetDiag()
 	}
 	if err = d.Set("replication_status", share.ReplicationStatus); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting replication_status: %s", err))
+		err = fmt.Errorf("Error setting replication_status: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-replication_status").GetDiag()
 	}
 
 	if share.ReplicationStatusReasons != nil {
 		err = d.Set("replication_status_reasons", dataSourceShareFlattenReplicationStatusReasons(share.ReplicationStatusReasons))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting replication_status_reasons %s", err))
+			err = fmt.Errorf("Error setting replication_status_reasons: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-replication_status_reasons").GetDiag()
 		}
 	}
 
 	if share.ResourceGroup != nil {
 		err = d.Set("resource_group", *share.ResourceGroup.ID)
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting resource_group %s", err))
+			err = fmt.Errorf("Error setting resource_group: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-resource_group").GetDiag()
 		}
 	}
 	if err = d.Set("resource_type", share.ResourceType); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting resource_type: %s", err))
+		err = fmt.Errorf("Error setting resource_type: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-resource_type").GetDiag()
 	}
 	if err = d.Set("size", share.Size); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting size: %s", err))
+		err = fmt.Errorf("Error setting size: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-size").GetDiag()
 	}
 	if share.SourceShare != nil {
 		err = d.Set("source_share", dataSourceShareFlattenSourceShare(*share.SourceShare))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting source_share %s", err))
+			err = fmt.Errorf("Error setting source_share: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-source_share").GetDiag()
 		}
 	}
 	if share.MountTargets != nil {
 		err = d.Set("share_targets", dataSourceShareFlattenTargets(share.MountTargets))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting targets %s", err))
+			err = fmt.Errorf("Error setting share_targets: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-share_targets").GetDiag()
 		}
 		err = d.Set("mount_targets", dataSourceShareFlattenTargets(share.MountTargets))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting targets %s", err))
+			err = fmt.Errorf("Error setting mount_targets: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-mount_targets").GetDiag()
 		}
 	}
 
 	if share.Zone != nil {
 		err = d.Set("zone", *share.Zone.Name)
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting zone %s", err))
+			err = fmt.Errorf("Error setting zone: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share", "read", "set-zone").GetDiag()
 		}
 	}
 	if err = d.Set("snapshot_count", flex.IntValue(share.SnapshotCount)); err != nil {
@@ -797,14 +823,16 @@ func dataSourceIbmIsShareRead(context context.Context, d *schema.ResourceData, m
 	}
 	accesstags, err := flex.GetGlobalTagsUsingCRN(meta, *share.CRN, "", isAccessTagType)
 	if err != nil {
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error setting shares (%s) access tags: %s", d.Id(), err), "(Data) ibm_is_share", "read")
 		log.Printf(
-			"Error getting shares (%s) access tags: %s", d.Id(), err)
+			"[ERROR] %s", tfErr.GetDebugMessage())
 	}
 
 	if share.UserTags != nil {
 		if err = d.Set(isFileShareTags, share.UserTags); err != nil {
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error setting shares (%s) user tags: %s", d.Id(), err), "(Data) ibm_is_share", "read")
 			log.Printf(
-				"Error setting shares (%s) user tags: %s", d.Id(), err)
+				"[ERROR] %s", tfErr.GetDebugMessage())
 		}
 	}
 
diff --git a/ibm/service/vpc/data_source_ibm_is_share_accessor_binding.go b/ibm/service/vpc/data_source_ibm_is_share_accessor_binding.go
index c4030f99c2..75150eabee 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_accessor_binding.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_accessor_binding.go
@@ -157,8 +157,7 @@ func DataSourceIBMIsShareAccessorBinding() *schema.Resource {
 func dataSourceIBMIsShareAccessorBindingRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		// Error is coming from SDK client, so it doesn't need to be discriminated.
-		tfErr := flex.TerraformErrorf(err, err.Error(), "(Data) ibm_is_share_accessor_binding", "read")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_accessor_binding", "read")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
diff --git a/ibm/service/vpc/data_source_ibm_is_share_accessor_bindings.go b/ibm/service/vpc/data_source_ibm_is_share_accessor_bindings.go
index 4fefad2bd3..f5086321ed 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_accessor_bindings.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_accessor_bindings.go
@@ -167,7 +167,7 @@ func DataSourceIBMIsShareAccessorBindings() *schema.Resource {
 func dataSourceIBMIsShareAccessorBindingsRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		tfErr := flex.TerraformErrorf(err, err.Error(), "(Data) ibm_is_share_accessor_bindings", "read")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_accessor_bindings", "read")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
@@ -204,8 +204,7 @@ func dataSourceIBMIsShareAccessorBindingsRead(context context.Context, d *schema
 	}
 
 	if err = d.Set("accessor_bindings", mapSlice); err != nil {
-		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error setting accessor_bindings %s", err), "(Data) ibm_is_share_accessor_bindings", "read")
-		return tfErr.GetDiag()
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting accessor_bindings: %s", err), "(Data) ibm_is_share_accessor_bindings", "read", "set-accessor_bindings").GetDiag()
 	}
 
 	return nil
diff --git a/ibm/service/vpc/data_source_ibm_is_share_mount_target.go b/ibm/service/vpc/data_source_ibm_is_share_mount_target.go
index 8b2ec5dea9..cf0e36a716 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_mount_target.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_mount_target.go
@@ -9,6 +9,7 @@ import (
 	"log"
 
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/conns"
+	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/flex"
 	"github.com/IBM/vpc-go-sdk/vpcv1"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
@@ -279,7 +280,9 @@ func DataSourceIBMIsShareTarget() *schema.Resource {
 func dataSourceIBMIsShareTargetRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_mount_target", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	share_id := d.Get("share").(string)
@@ -292,8 +295,9 @@ func dataSourceIBMIsShareTargetRead(context context.Context, d *schema.ResourceD
 		listSharesOptions.Name = &share_name
 		shareCollection, response, err := vpcClient.ListSharesWithContext(context, listSharesOptions)
 		if err != nil {
-			log.Printf("[DEBUG] ListSharesWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListSharesWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share_mount_target", "read")
+			log.Printf("[DEBUG] %s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		for _, sharesItem := range shareCollection.Shares {
 			if *sharesItem.Name == share_name {
@@ -310,8 +314,9 @@ func dataSourceIBMIsShareTargetRead(context context.Context, d *schema.ResourceD
 
 		shareTargetCollection, response, err := vpcClient.ListShareMountTargetsWithContext(context, listShareTargetsOptions)
 		if err != nil {
-			log.Printf("[DEBUG] ListShareTargetsWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListShareTargetsWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share_mount_target", "read")
+			log.Printf("[DEBUG] %s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		for _, targetsItem := range shareTargetCollection.MountTargets {
 			if *targetsItem.Name == share_target_name {
@@ -325,8 +330,9 @@ func dataSourceIBMIsShareTargetRead(context context.Context, d *schema.ResourceD
 		getShareTargetOptions.SetID(share_target)
 		shareTarget1, response, err := vpcClient.GetShareMountTargetWithContext(context, getShareTargetOptions)
 		if err != nil {
-			log.Printf("[DEBUG] GetShareTargetWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("GetShareTargetWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share_mount_target", "read")
+			log.Printf("[DEBUG] %s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		shareTarget = shareTarget1
 	}
@@ -334,56 +340,69 @@ func dataSourceIBMIsShareTargetRead(context context.Context, d *schema.ResourceD
 	d.SetId(fmt.Sprintf("%s/%s", share_id, *shareTarget.ID))
 	if shareTarget.AccessControlMode != nil {
 		d.Set("access_control_mode", *shareTarget.AccessControlMode)
+		err = fmt.Errorf("Error setting access_control_mode: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-access_control_mode").GetDiag()
 	}
 	if err = d.Set("created_at", shareTarget.CreatedAt.String()); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting created_at: %s", err))
+		err = fmt.Errorf("Error setting created_at: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-created_at").GetDiag()
 	}
 	if err = d.Set("href", shareTarget.Href); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting href: %s", err))
+		err = fmt.Errorf("Error setting href: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-href").GetDiag()
 	}
 	if err = d.Set("lifecycle_state", shareTarget.LifecycleState); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting lifecycle_state: %s", err))
+		err = fmt.Errorf("Error setting lifecycle_state: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-lifecycle_state").GetDiag()
 	}
 	if err = d.Set("mount_path", shareTarget.MountPath); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting mount_path: %s", err))
+		err = fmt.Errorf("Error setting mount_path: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-mount_path").GetDiag()
 	}
 	if err = d.Set("name", shareTarget.Name); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting name: %s", err))
+		err = fmt.Errorf("Error setting name: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-name").GetDiag()
 	}
 	if err = d.Set("resource_type", shareTarget.ResourceType); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting resource_type: %s", err))
+		err = fmt.Errorf("Error setting resource_type: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-resource_type").GetDiag()
 	}
 	if shareTarget.TransitEncryption != nil {
 		if err = d.Set("transit_encryption", *shareTarget.TransitEncryption); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting transit_encryption: %s", err))
+			err = fmt.Errorf("Error setting transit_encryption: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-transit_encryption").GetDiag()
 		}
 	}
 
 	if shareTarget.PrimaryIP != nil {
 		err = d.Set("primary_ip", dataSourceShareMountTargetFlattenPrimaryIP(*shareTarget.PrimaryIP))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting vpc %s", err))
+			err = fmt.Errorf("Error setting primary_ip: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-primary_ip").GetDiag()
 		}
 	}
 
 	if shareTarget.VPC != nil {
 		err = d.Set("vpc", dataSourceShareMountTargetFlattenVpc(*shareTarget.VPC))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting vpc %s", err))
+			err = fmt.Errorf("Error setting vpc: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-vpc").GetDiag()
 		}
 	}
 
 	if shareTarget.VirtualNetworkInterface != nil {
 		err = d.Set("virtual_network_interface", dataSourceShareMountTargetFlattenVNI(*shareTarget.VirtualNetworkInterface))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting vpc %s", err))
+			err = fmt.Errorf("Error setting virtual_network_interface: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-virtual_network_interface").GetDiag()
 		}
 	}
 
 	if shareTarget.Subnet != nil {
 		err = d.Set("subnet", dataSourceShareMountTargetFlattenSubnet(*shareTarget.Subnet))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting subnet %s", err))
+			err = fmt.Errorf("Error setting subnet: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_target", "read", "set-subnet").GetDiag()
 		}
 	}
 
diff --git a/ibm/service/vpc/data_source_ibm_is_share_mount_targets.go b/ibm/service/vpc/data_source_ibm_is_share_mount_targets.go
index 6a8645360f..0f2f1a786c 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_mount_targets.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_mount_targets.go
@@ -284,7 +284,9 @@ func DataSourceIBMIsShareTargets() *schema.Resource {
 func dataSourceIBMIsShareTargetsRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_mount_targets", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	start := ""
@@ -301,8 +303,9 @@ func dataSourceIBMIsShareTargetsRead(context context.Context, d *schema.Resource
 		}
 		shareTargetCollection, response, err := vpcClient.ListShareMountTargetsWithContext(context, listShareTargetsOptions)
 		if err != nil {
-			log.Printf("[DEBUG] ListShareTargetsWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListShareTargetsWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share_mount_targets", "read")
+			log.Printf("[DEBUG] %s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		start = flex.GetNext(shareTargetCollection.Next)
 		allrecs = append(allrecs, shareTargetCollection.MountTargets...)
@@ -316,7 +319,8 @@ func dataSourceIBMIsShareTargetsRead(context context.Context, d *schema.Resource
 	if len(allrecs) > 0 {
 		err = d.Set("mount_targets", dataSourceShareMountTargetCollectionFlattenTargets(allrecs))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting targets %s", err))
+			err = fmt.Errorf("Error setting mount_targets: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_mount_targets", "read", "set-mount_targets").GetDiag()
 		}
 	}
 
diff --git a/ibm/service/vpc/data_source_ibm_is_share_profile.go b/ibm/service/vpc/data_source_ibm_is_share_profile.go
index 9daeb3f9d5..500d917cd7 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_profile.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_profile.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/conns"
+	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/flex"
 	"github.com/IBM/vpc-go-sdk/vpcv1"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
@@ -136,7 +137,9 @@ func DataSourceIbmIsShareProfile() *schema.Resource {
 func dataSourceIbmIsShareProfileRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_profile", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	getShareProfileOptions := &vpcv1.GetShareProfileOptions{}
@@ -145,8 +148,9 @@ func dataSourceIbmIsShareProfileRead(context context.Context, d *schema.Resource
 
 	shareProfile, response, err := vpcClient.GetShareProfileWithContext(context, getShareProfileOptions)
 	if err != nil {
-		log.Printf("[DEBUG] GetShareProfileWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("GetShareProfileWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share_profile", "read")
+		log.Printf("[DEBUG] %s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	if shareProfile.Capacity != nil {
@@ -155,7 +159,8 @@ func dataSourceIbmIsShareProfileRead(context context.Context, d *schema.Resource
 		capacityMap := dataSourceShareProfileCapacityToMap(*capacity)
 		capacityList = append(capacityList, capacityMap)
 		if err = d.Set("capacity", capacityList); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting capacity: %s", err))
+			err = fmt.Errorf("Error setting capacity: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profile", "read", "set-capacity").GetDiag()
 		}
 	}
 	if shareProfile.Iops != nil {
@@ -164,18 +169,22 @@ func dataSourceIbmIsShareProfileRead(context context.Context, d *schema.Resource
 		iopsMap := dataSourceShareProfileIopsToMap(*iops)
 		iopsList = append(iopsList, iopsMap)
 		if err = d.Set("iops", iopsList); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting iops: %s", err))
+			err = fmt.Errorf("Error setting iops: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profile", "read", "set-iops").GetDiag()
 		}
 	}
 	d.SetId(*shareProfile.Name)
 	if err = d.Set("family", shareProfile.Family); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting family: %s", err))
+		err = fmt.Errorf("Error setting family: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profile", "read", "set-family").GetDiag()
 	}
 	if err = d.Set("href", shareProfile.Href); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting href: %s", err))
+		err = fmt.Errorf("Error setting href: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profile", "read", "set-href").GetDiag()
 	}
 	if err = d.Set("resource_type", shareProfile.ResourceType); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting resource_type: %s", err))
+		err = fmt.Errorf("Error setting resource_type: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profile", "read", "set-resource_type").GetDiag()
 	}
 
 	return nil
diff --git a/ibm/service/vpc/data_source_ibm_is_share_profiles.go b/ibm/service/vpc/data_source_ibm_is_share_profiles.go
index f01f371882..ee7c3f5cfb 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_profiles.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_profiles.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/conns"
+	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/flex"
 	"github.com/IBM/vpc-go-sdk/vpcv1"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
@@ -151,15 +152,18 @@ func DataSourceIbmIsShareProfiles() *schema.Resource {
 func dataSourceIbmIsShareProfilesRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_profiles", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	listShareProfilesOptions := &vpcv1.ListShareProfilesOptions{}
 
 	shareProfileCollection, response, err := vpcClient.ListShareProfilesWithContext(context, listShareProfilesOptions)
 	if err != nil {
-		log.Printf("[DEBUG] ListShareProfilesWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListShareProfilesWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_share_profiles", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	d.SetId(dataSourceIbmIsShareProfilesID(d))
@@ -167,11 +171,13 @@ func dataSourceIbmIsShareProfilesRead(context context.Context, d *schema.Resourc
 	if shareProfileCollection.Profiles != nil {
 		err = d.Set("profiles", dataSourceShareProfileCollectionFlattenProfiles(shareProfileCollection.Profiles))
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting profiles %s", err))
+			err = fmt.Errorf("Error setting profiles: %s", err)
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profiles", "read", "set-profiles").GetDiag()
 		}
 	}
 	if err = d.Set("total_count", shareProfileCollection.TotalCount); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting total_count: %s", err))
+		err = fmt.Errorf("Error setting total_count: %s", err)
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "(Data) ibm_is_share_profiles", "read", "set-total_count").GetDiag()
 	}
 
 	return nil
diff --git a/ibm/service/vpc/data_source_ibm_is_share_snapshot.go b/ibm/service/vpc/data_source_ibm_is_share_snapshot.go
index 96a57ef16d..48d513032e 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_snapshot.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_snapshot.go
@@ -246,8 +246,7 @@ func DataSourceIBMIsShareSnapshot() *schema.Resource {
 func dataSourceIBMIsShareSnapshotRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		// Error is coming from SDK client, so it doesn't need to be discriminated.
-		tfErr := flex.TerraformErrorf(err, err.Error(), "(Data) ibm_is_share_snapshot", "read")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_snapshot", "read")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
diff --git a/ibm/service/vpc/data_source_ibm_is_share_snapshots.go b/ibm/service/vpc/data_source_ibm_is_share_snapshots.go
index 2cd2d866ae..2345e4680c 100644
--- a/ibm/service/vpc/data_source_ibm_is_share_snapshots.go
+++ b/ibm/service/vpc/data_source_ibm_is_share_snapshots.go
@@ -266,7 +266,7 @@ func DataSourceIBMIsShareSnapshots() *schema.Resource {
 func dataSourceIBMIsShareSnapshotsRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		tfErr := flex.TerraformErrorf(err, err.Error(), "(Data) ibm_is_share_snapshots", "read")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_share_snapshots", "read")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
@@ -314,8 +314,7 @@ func dataSourceIBMIsShareSnapshotsRead(context context.Context, d *schema.Resour
 	}
 
 	if err = d.Set("snapshots", mapSlice); err != nil {
-		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error setting snapshots %s", err), "(Data) ibm_is_share_snapshots", "read")
-		return tfErr.GetDiag()
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("Error setting snapshots: %s", err), "(Data) ibm_is_share_snapshots", "read", "set-snapshots").GetDiag()
 	}
 
 	return nil
diff --git a/ibm/service/vpc/data_source_ibm_is_shares.go b/ibm/service/vpc/data_source_ibm_is_shares.go
index 58ac287351..b53a4d6fea 100644
--- a/ibm/service/vpc/data_source_ibm_is_shares.go
+++ b/ibm/service/vpc/data_source_ibm_is_shares.go
@@ -576,7 +576,9 @@ func DataSourceIbmIsShares() *schema.Resource {
 func dataSourceIbmIsSharesRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "(Data) ibm_is_shares", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 	shareName := ""
 	if shareNameIntf, ok := d.GetOk("name"); ok {
@@ -603,8 +605,9 @@ func dataSourceIbmIsSharesRead(context context.Context, d *schema.ResourceData,
 		}
 		shareCollection, response, err := vpcClient.ListSharesWithContext(context, listSharesOptions)
 		if err != nil {
-			log.Printf("[DEBUG] ListSharesWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListSharesWithContext failed: %s\n%s", err.Error(), response), "(Data) ibm_is_shares", "read")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		if totalCount == 0 {
 			totalCount = int(*shareCollection.TotalCount)
@@ -625,7 +628,8 @@ func dataSourceIbmIsSharesRead(context context.Context, d *schema.ResourceData,
 		}
 		errSettingShares := d.Set("shares", shares)
 		if errSettingShares != nil {
-			return diag.FromErr(fmt.Errorf("Error setting shares %s", errSettingShares))
+			errSettingShares = fmt.Errorf("Error setting shares: %s", errSettingShares)
+			return flex.DiscriminatedTerraformErrorf(errSettingShares, errSettingShares.Error(), "(Data) ibm_is_shares", "read", "set-shares").GetDiag()
 		}
 	}
 	if err = d.Set("total_count", totalCount); err != nil {
diff --git a/ibm/service/vpc/resource_ibm_is_share.go b/ibm/service/vpc/resource_ibm_is_share.go
index 18269e71e3..b669859369 100644
--- a/ibm/service/vpc/resource_ibm_is_share.go
+++ b/ibm/service/vpc/resource_ibm_is_share.go
@@ -1045,8 +1045,11 @@ func ResourceIbmIsShareValidator() *validate.ResourceValidator {
 
 func resourceIbmIsShareCreate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
+
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	createShareOptions := &vpcv1.CreateShareOptions{}
@@ -1138,7 +1141,9 @@ func resourceIbmIsShareCreate(context context.Context, d *schema.ResourceData, m
 					autoDeleteSchema := fmt.Sprintf("replica_share.0.mount_targets.%d.virtual_network_interface.0.auto_delete", tergetIdx)
 					targetsItem, err := resourceIbmIsShareMapToShareMountTargetPrototype(d, target, autoDeleteSchema)
 					if err != nil {
-						return diag.FromErr(err)
+						tfErr := flex.TerraformErrorf(err, fmt.Sprintf("resourceIbmIsShareMapToShareMountTargetPrototype failed: %s", err.Error()), "ibm_is_share", "create")
+						log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+						return tfErr.GetDiag()
 					}
 					targets = append(targets, &targetsItem)
 				}
@@ -1213,7 +1218,9 @@ func resourceIbmIsShareCreate(context context.Context, d *schema.ResourceData, m
 			autoDeleteSchema := fmt.Sprintf("mount_targets.%d.virtual_network_interface.0.auto_delete", targetIdx)
 			targetsItem, err := resourceIbmIsShareMapToShareMountTargetPrototype(d, value, autoDeleteSchema)
 			if err != nil {
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("resourceIbmIsShareMapToShareMountTargetPrototype failed: %s", err.Error()), "ibm_is_share", "create")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 			targets = append(targets, &targetsItem)
 		}
@@ -1247,19 +1254,24 @@ func resourceIbmIsShareCreate(context context.Context, d *schema.ResourceData, m
 	createShareOptions.SetSharePrototype(sharePrototype)
 	share, response, err := vpcClient.CreateShareWithContext(context, createShareOptions)
 	if err != nil {
-		log.Printf("[DEBUG] CreateShareWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("create share failed: %s\n%s", err.Error(), response), "ibm_is_share", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	_, err = isWaitForShareAvailable(context, vpcClient, *share.ID, d, d.Timeout(schema.TimeoutCreate))
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("wait for share available failed: %s\n%s", err.Error(), response), "ibm_is_share", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	if share.ReplicaShare != nil && share.ReplicaShare.ID != nil {
 		_, err = isWaitForShareAvailable(context, vpcClient, *share.ReplicaShare.ID, d, d.Timeout(schema.TimeoutCreate))
 		if err != nil {
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("wait for share available  failed: %s\n%s", err.Error(), response), "ibm_is_share", "create")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		replicaShareAccessTagsSchema := "replica_share.0.access_tags"
 		if _, ok := d.GetOk(replicaShareAccessTagsSchema); ok {
@@ -1324,7 +1336,9 @@ func resourceIbmIsShareMapToShareMountTargetPrototype(d *schema.ResourceData, sh
 func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	getShareOptions := &vpcv1.GetShareOptions{}
@@ -1337,18 +1351,19 @@ func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, met
 			d.SetId("")
 			return nil
 		}
-		log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Get share failed: %s\n%s", err.Error(), response), "ibm_is_share", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	if share.EncryptionKey != nil {
 		if err = d.Set("encryption_key", *share.EncryptionKey.CRN); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting encryption_key: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-encryption_key").GetDiag()
 		}
 	}
 	if share.AccessControlMode != nil {
 		if err = d.Set("access_control_mode", *share.AccessControlMode); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting access_control_mode: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-access_control_mode").GetDiag()
 		}
 	}
 	if !core.IsNil(share.AllowedTransitEncryptionModes) {
@@ -1365,23 +1380,23 @@ func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, met
 		}
 	}
 	if err = d.Set("iops", flex.IntValue(share.Iops)); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting iops: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-iops").GetDiag()
 	}
 	if err = d.Set("name", share.Name); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting name: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-name").GetDiag()
 	}
 	if share.Profile != nil {
 		if err = d.Set("profile", *share.Profile.Name); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting profile: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-profile").GetDiag()
 		}
 	}
 	if share.ResourceGroup != nil {
 		if err = d.Set("resource_group", *share.ResourceGroup.ID); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting resource_group: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-resource_group").GetDiag()
 		}
 	}
 	if err = d.Set("size", flex.IntValue(share.Size)); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting size: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-size").GetDiag()
 	}
 	if err = d.Set("accessor_binding_role", share.AccessorBindingRole); err != nil {
 		err = fmt.Errorf("Error setting accessor_binding_role: %s", err)
@@ -1412,18 +1427,22 @@ func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, met
 					return nil
 				}
 				log.Printf("[DEBUG] GetShareMountTargetWithContext failed %s\n%s", err, response)
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Get share mount target failed: %s\n%s", err.Error(), response), "ibm_is_share", "read")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 
 			targetsItemMap, err := ShareMountTargetToMap(context, vpcClient, d, *shareTarget)
 			if err != nil {
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ShareMountTargetToMap failed: %s", err.Error()), "ibm_is_share", "read")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 			targets = append(targets, targetsItemMap)
 		}
 	}
 	if err = d.Set("mount_targets", targets); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting mount_targets: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-mount_targets").GetDiag()
 	}
 
 	replicaShare := []map[string]interface{}{}
@@ -1439,12 +1458,15 @@ func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, met
 					d.SetId("")
 					return nil
 				}
-				log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Get share failed: %s\n%s", err.Error(), response), "ibm_is_share", "read")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 			replicaShareItem, err := ShareReplicaToMap(context, vpcClient, d, meta, *share)
 			if err != nil {
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ShareReplicaToMap failed: %s", err.Error()), "ibm_is_share", "read")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 			replicaShare = append(replicaShare, replicaShareItem)
 			d.Set("replica_share", replicaShare)
@@ -1453,31 +1475,31 @@ func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, met
 
 	if share.Zone != nil {
 		if err = d.Set("zone", *share.Zone.Name); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting zone: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-zone").GetDiag()
 		}
 	}
 	if err = d.Set("created_at", share.CreatedAt.String()); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting created_at: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-created_at").GetDiag()
 	}
 	if err = d.Set("crn", share.CRN); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting crn: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-crn").GetDiag()
 	}
 	if err = d.Set("encryption", share.Encryption); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting encryption: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-encryption").GetDiag()
 	}
 	if err = d.Set("href", share.Href); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting href: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-href").GetDiag()
 	}
 	if share.LifecycleReasons != nil {
 		if err := d.Set("lifecycle_reasons", resourceShareLifecycleReasons(share.LifecycleReasons)); err != nil {
-			return diag.FromErr(fmt.Errorf("[ERROR] Error setting lifecycle_reasons: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-lifecycle_reasons").GetDiag()
 		}
 	}
 	if err = d.Set("lifecycle_state", share.LifecycleState); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting lifecycle_state: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-lifecycle_state").GetDiag()
 	}
 	if err = d.Set("resource_type", share.ResourceType); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting resource_type: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share", "read", "set-resource_type").GetDiag()
 	}
 	if err = d.Set("snapshot_count", flex.IntValue(share.SnapshotCount)); err != nil {
 		err = fmt.Errorf("Error setting snapshot_count: %s", err)
@@ -1565,7 +1587,9 @@ func resourceIbmIsShareRead(context context.Context, d *schema.ResourceData, met
 func resourceIbmIsShareUpdate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share", "update")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	getShareOptions := &vpcv1.GetShareOptions{}
@@ -1578,14 +1602,17 @@ func resourceIbmIsShareUpdate(context context.Context, d *schema.ResourceData, m
 			d.SetId("")
 			return nil
 		}
-		log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Get share failed: %s\n%s", err.Error(), response), "ibm_is_share", "update")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 	eTag := response.Headers.Get("ETag")
 
 	err = shareUpdate(vpcClient, context, d, meta, "share", d.Id(), eTag)
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("shareUpdate failed: %s", err.Error()), "ibm_is_share", "update")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 	if d.HasChange("replica_share") {
 		if share.ReplicaShare != nil && share.ReplicaShare.ID != nil {
@@ -1598,13 +1625,16 @@ func resourceIbmIsShareUpdate(context context.Context, d *schema.ResourceData, m
 					d.SetId("")
 					return nil
 				}
-				log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Get share failed: %s\n%s", err.Error(), response), "ibm_is_share", "update")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 			eTag := response.Headers.Get("ETag")
 			err = shareUpdate(vpcClient, context, d, meta, "replica_share", *replicaShare.ID, eTag)
 			if err != nil {
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("shareUpdate failed: %s", err.Error()), "ibm_is_share", "update")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 		}
 	}
@@ -1622,8 +1652,11 @@ func resourceIbmIsShareUpdate(context context.Context, d *schema.ResourceData, m
 
 func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
+
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share", "delete")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	getShareOptions := &vpcv1.GetShareOptions{}
@@ -1636,8 +1669,9 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 			d.SetId("")
 			return nil
 		}
-		log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share err %s\n%s", err, response), "ibm_is_share", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return diag.FromErr(tfErr)
 	}
 	if share.MountTargets != nil {
 		if _, ok := d.GetOk("mount_targets"); ok {
@@ -1650,12 +1684,15 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 
 				_, response, err := vpcClient.DeleteShareMountTargetWithContext(context, deleteShareMountTargetOptions)
 				if err != nil {
-					log.Printf("[DEBUG] DeleteShareMountTargetWithContext failed %s\n%s", err, response)
-					return diag.FromErr(err)
+					tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share err share mount target %s\n%s", err, response), "ibm_is_share", "delete")
+					log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+					return diag.FromErr(tfErr)
 				}
 				_, err = isWaitForTargetDelete(context, vpcClient, d, d.Id(), *targetsItem.ID)
 				if err != nil {
-					return diag.FromErr(err)
+					tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Wait for target delete failed: %s", err.Error()), "ibm_is_share", "delete")
+					log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+					return tfErr.GetDiag()
 				}
 			}
 		}
@@ -1673,8 +1710,9 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 					d.SetId("")
 					return nil
 				}
-				log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share err %s\n%s", err, response), "ibm_is_share", "delete")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return diag.FromErr(tfErr)
 			}
 			if replicaShare.MountTargets != nil {
 				if _, ok := d.GetOk("replica_share.0.mount_targets"); ok {
@@ -1687,12 +1725,15 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 
 						_, response, err := vpcClient.DeleteShareMountTargetWithContext(context, deleteShareMountTargetOptions)
 						if err != nil {
-							log.Printf("[DEBUG] DeleteShareMountTargetWithContext failed %s\n%s", err, response)
-							return diag.FromErr(err)
+							tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share err share mount target %s\n%s", err, response), "ibm_is_share", "delete")
+							log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+							return diag.FromErr(tfErr)
 						}
 						_, err = isWaitForTargetDelete(context, vpcClient, d, d.Id(), *targetsItem.ID)
 						if err != nil {
-							return diag.FromErr(err)
+							tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Wait for target delete failed: %s", err.Error()), "ibm_is_share", "delete")
+							log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+							return tfErr.GetDiag()
 						}
 					}
 				}
@@ -1703,8 +1744,9 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 					d.SetId("")
 					return nil
 				}
-				log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share err %s\n%s", err, response), "ibm_is_share", "delete")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return diag.FromErr(tfErr)
 			}
 			replicaETag := response.Headers.Get("ETag")
 			deleteShareOptions := &vpcv1.DeleteShareOptions{}
@@ -1712,13 +1754,16 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 			deleteShareOptions.SetID(*replicaShare.ID)
 			_, response, err = vpcClient.DeleteShareWithContext(context, deleteShareOptions)
 			if err != nil {
-				log.Printf("[DEBUG] DeleteShareWithContext failed %s\n%s", err, response)
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share err  %s\n%s", err, response), "ibm_is_share", "delete")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return diag.FromErr(tfErr)
 			}
 
 			_, err = isWaitForShareDelete(context, vpcClient, d, *replicaShare.ID)
 			if err != nil {
-				return diag.FromErr(err)
+				tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Wait for share delete failed: %s", err.Error()), "ibm_is_share", "delete")
+				log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+				return tfErr.GetDiag()
 			}
 		}
 	}
@@ -1728,8 +1773,9 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 			d.SetId("")
 			return nil
 		}
-		log.Printf("[DEBUG] GetShareWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("shaGetShareWithContextre faialed %s\n%s", err, response), "ibm_is_share", "delete")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return diag.FromErr(tfErr)
 	}
 	ETag := response.Headers.Get("ETag")
 	deleteShareOptions := &vpcv1.DeleteShareOptions{}
@@ -1738,13 +1784,16 @@ func resourceIbmIsShareDelete(context context.Context, d *schema.ResourceData, m
 	deleteShareOptions.IfMatch = &ETag
 	_, response, err = vpcClient.DeleteShareWithContext(context, deleteShareOptions)
 	if err != nil {
-		log.Printf("[DEBUG] DeleteShareWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("DeleteShareWithContext failed %s\n%s", err, response), "ibm_is_share", "delete")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return diag.FromErr(tfErr)
 	}
 
 	_, err = isWaitForShareDelete(context, vpcClient, d, d.Id())
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Wait for share delete failed: %s", err.Error()), "ibm_is_share", "delete")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	d.SetId("")
diff --git a/ibm/service/vpc/resource_ibm_is_share_delete_accessor_binding.go b/ibm/service/vpc/resource_ibm_is_share_delete_accessor_binding.go
index e334e57f80..3b7285f02a 100644
--- a/ibm/service/vpc/resource_ibm_is_share_delete_accessor_binding.go
+++ b/ibm/service/vpc/resource_ibm_is_share_delete_accessor_binding.go
@@ -45,7 +45,9 @@ func ResourceIbmIsShareDeleteAccessorBinding() *schema.Resource {
 func resourceIbmIsShareDeleteAccessorBindingCreate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_delete_accessor_binding", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	share_id := d.Get("share").(string)
@@ -58,13 +60,12 @@ func resourceIbmIsShareDeleteAccessorBindingCreate(context context.Context, d *s
 	}
 	response, err := vpcClient.DeleteShareAccessorBindingWithContext(context, deleteAccessBindingOptions)
 	if err != nil {
-		log.Printf("[DEBUG] DeleteShareAccessorBindingWithContext failed %s\n%s", err, response)
-		return diag.FromErr(fmt.Errorf("[ERROR] DeleteShareAccessorBindingWithContext failed %s\n%s", err, response))
+		return flex.TerraformErrorf(err, fmt.Sprintf("DeleteShareAccessorBindingWithContext failed: %s\n%s", err.Error(), response), "ibm_is_share_delete_accessor_binding", "delete").GetDiag()
 	}
 
 	_, err = isWaitForShareAccessorBindingDeleted(context, vpcClient, share_id, bindingId, d, d.Timeout(schema.TimeoutCreate))
 	if err != nil {
-		return diag.FromErr(err)
+		return flex.TerraformErrorf(err, fmt.Sprintf("isWaitForShareAccessorBindingDeleted failed: %s", err.Error()), "ibm_is_share_delete_accessor_binding", "delete").GetDiag()
 	}
 	d.SetId(share_id)
 	return nil
diff --git a/ibm/service/vpc/resource_ibm_is_share_mount_target.go b/ibm/service/vpc/resource_ibm_is_share_mount_target.go
index ee7397f0e8..481c567604 100644
--- a/ibm/service/vpc/resource_ibm_is_share_mount_target.go
+++ b/ibm/service/vpc/resource_ibm_is_share_mount_target.go
@@ -280,7 +280,10 @@ func isWaitForOldTargetDelete(context context.Context, vpcClient *vpcv1.VpcV1, d
 func resourceIBMIsShareMountTargetCreate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_mount_target", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
+
 	}
 
 	//Temporary code to fix concurrent mount target issues.
@@ -295,8 +298,9 @@ func resourceIBMIsShareMountTargetCreate(context context.Context, d *schema.Reso
 			d.SetId("")
 			return nil
 		}
-		log.Printf("[DEBUG] ListShareMountTargetsWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("ListShareMountTargetsWithContext failed: %s\n%s", err.Error(), response), "ibm_is_share_mount_target", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 	for _, mountTargets := range shareTargets.MountTargets {
 		if mountTargets.VPC != nil && *mountTargets.VPC.ID == vpcId {
@@ -304,7 +308,7 @@ func resourceIBMIsShareMountTargetCreate(context context.Context, d *schema.Reso
 			if *mountTargets.LifecycleState == "deleting" {
 				_, err = isWaitForTargetDelete(context, vpcClient, d, shareId, *mountTargets.ID)
 				if err != nil {
-					return diag.FromErr(err)
+					return flex.TerraformErrorf(err, fmt.Sprintf("isWaitForTargetDelete failed: %s", err.Error()), "ibm_is_share_mount_target", "create").GetDiag()
 				}
 			}
 		}
@@ -331,7 +335,7 @@ func resourceIBMIsShareMountTargetCreate(context context.Context, d *schema.Reso
 		} else {
 			vniPrototype, err = ShareMountTargetMapToShareMountTargetPrototype(d, vniMap, "virtual_network_interface.0.auto_delete")
 			if err != nil {
-				return diag.FromErr(err)
+				return flex.TerraformErrorf(err, fmt.Sprintf("ShareMountTargetMapToShareMountTargetPrototype failed: %s", err.Error()), "ibm_is_share_mount_target", "create").GetDiag()
 			}
 		}
 		shareMountTargetPrototype.VirtualNetworkInterface = &vniPrototype
@@ -347,19 +351,20 @@ func resourceIBMIsShareMountTargetCreate(context context.Context, d *schema.Reso
 	createShareMountTargetOptions.ShareMountTargetPrototype = shareMountTargetPrototype
 	shareTarget, response, err := vpcClient.CreateShareMountTargetWithContext(context, createShareMountTargetOptions)
 	if err != nil || shareTarget == nil {
-		log.Printf("[DEBUG] CreateShareMountTargetWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("CreateShareMountTargetWithContext failed: %s\n%s", err.Error(), response), "ibm_is_share_mount_target", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 	d.SetId(fmt.Sprintf("%s/%s", *createShareMountTargetOptions.ShareID, *shareTarget.ID))
 	if shareTarget.VirtualNetworkInterface != nil {
 		_, err = WaitForVNIAvailable(vpcClient, *shareTarget.VirtualNetworkInterface.ID, d, d.Timeout(schema.TimeoutCreate))
 		if err != nil {
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("WaitForVNIAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "create").GetDiag()
 		}
 	}
 	_, err = WaitForMountTargetAvailable(context, vpcClient, *createShareMountTargetOptions.ShareID, *shareTarget.ID, d, d.Timeout(schema.TimeoutCreate))
 	if err != nil {
-		return diag.FromErr(err)
+		return flex.TerraformErrorf(err, fmt.Sprintf("WaitForMountTargetAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "create").GetDiag()
 	}
 
 	d.Set("mount_target", *shareTarget.ID)
@@ -369,14 +374,16 @@ func resourceIBMIsShareMountTargetCreate(context context.Context, d *schema.Reso
 func resourceIBMIsShareMountTargetRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_mount_target", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	getShareMountTargetOptions := &vpcv1.GetShareMountTargetOptions{}
 
 	parts, err := flex.IdParts(d.Id())
 	if err != nil {
-		return diag.FromErr(err)
+		return flex.TerraformErrorf(err, fmt.Sprintf("Split ID parts failed: %s", err.Error()), "ibm_is_share_mount_target", "read").GetDiag()
 	}
 
 	getShareMountTargetOptions.SetShareID(parts[0])
@@ -388,8 +395,9 @@ func resourceIBMIsShareMountTargetRead(context context.Context, d *schema.Resour
 			d.SetId("")
 			return nil
 		}
-		log.Printf("[DEBUG] GetShareMountTargetWithContext failed %s\n%s", err, response)
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("share mount target err %s\n%s", err, response), "ibm_is_share_mount_target", "read")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return diag.FromErr(tfErr)
 	}
 	if shareTarget.AccessControlMode != nil {
 		d.Set("access_control_mode", *shareTarget.AccessControlMode)
@@ -397,40 +405,41 @@ func resourceIBMIsShareMountTargetRead(context context.Context, d *schema.Resour
 	d.Set("mount_target", *shareTarget.ID)
 	if shareTarget.VPC != nil && shareTarget.VPC.ID != nil {
 		if err = d.Set("vpc", *shareTarget.VPC.ID); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting name: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting vpc: %s", err), "ibm_is_share_mount_target", "read", "set-vpc").GetDiag()
 		}
 	}
 	if shareTarget.VirtualNetworkInterface != nil {
 		vniList, err := ShareMountTargetVirtualNetworkInterfaceToMap(context, vpcClient, d, *shareTarget.VirtualNetworkInterface.ID)
 		if err != nil {
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("ShareMountTargetVirtualNetworkInterfaceToMap failed: %s", err.Error()), "ibm_is_share_mount_target", "read").GetDiag()
+
 		}
 		d.Set("virtual_network_interface", vniList)
 	}
 	if err = d.Set("name", *shareTarget.Name); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting name: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting name: %s", err), "ibm_is_share_mount_target", "read", "set-name").GetDiag()
 	}
 
 	if shareTarget.TransitEncryption != nil {
 		if err = d.Set("transit_encryption", *shareTarget.TransitEncryption); err != nil {
-			return diag.FromErr(fmt.Errorf("Error setting transit_encryption: %s", err))
+			return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting transit_encryption: %s", err), "ibm_is_share_mount_target", "read", "set-transit_encryption").GetDiag()
 		}
 	}
 
 	if err = d.Set("created_at", shareTarget.CreatedAt.String()); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting created_at: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting created_at: %s", err), "ibm_is_share_mount_target", "read", "set-created_at").GetDiag()
 	}
 	if err = d.Set("href", shareTarget.Href); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting href: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting href: %s", err), "ibm_is_share_mount_target", "read", "set-href").GetDiag()
 	}
 	if err = d.Set("lifecycle_state", shareTarget.LifecycleState); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting lifecycle_state: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting lifecycle_state: %s", err), "ibm_is_share_mount_target", "read", "set-lifecycle_state").GetDiag()
 	}
 	if err = d.Set("mount_path", shareTarget.MountPath); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting mount_path: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting mount_path: %s", err), "ibm_is_share_mount_target", "read", "set-mount_path").GetDiag()
 	}
 	if err = d.Set("resource_type", shareTarget.ResourceType); err != nil {
-		return diag.FromErr(fmt.Errorf("Error setting resource_type: %s", err))
+		return flex.DiscriminatedTerraformErrorf(err, fmt.Sprintf("[ERROR] Error setting resource_type: %s", err), "ibm_is_share_mount_target", "read", "set-resource_type").GetDiag()
 	}
 
 	return nil
@@ -439,7 +448,11 @@ func resourceIBMIsShareMountTargetRead(context context.Context, d *schema.Resour
 func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		if err != nil {
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_mount_target", "update")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
+		}
 	}
 
 	updateShareMountTargetOptions := &vpcv1.UpdateShareMountTargetOptions{}
@@ -448,7 +461,7 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 	shareId := parts[0]
 	mountTargetId := parts[1]
 	if err != nil {
-		return diag.FromErr(err)
+		return flex.TerraformErrorf(err, fmt.Sprintf("Split ID parts failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 	}
 
 	updateShareMountTargetOptions.SetShareID(shareId)
@@ -480,8 +493,7 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 		}
 		vniPatch, err := vniPatchModel.AsPatch()
 		if err != nil {
-			log.Printf("[DEBUG] Virtual network interface AsPatch failed %s", err)
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("vniPatchModel AsPatch failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 		}
 		shareTargetOptions := &vpcv1.GetShareMountTargetOptions{}
 
@@ -489,7 +501,9 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 		shareTargetOptions.SetID(mountTargetId)
 		shareTarget, _, err := vpcClient.GetShareMountTargetWithContext(context, shareTargetOptions)
 		if err != nil {
-			diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error while getting share mount target %s", err), "ibm_is_share_mount_target", "update")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		vniId := *shareTarget.VirtualNetworkInterface.ID
 		updateVNIOptions := &vpcv1.UpdateVirtualNetworkInterfaceOptions{
@@ -498,12 +512,13 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 		}
 		_, response, err := vpcClient.UpdateVirtualNetworkInterfaceWithContext(context, updateVNIOptions)
 		if err != nil {
-			log.Printf("[DEBUG] UpdateShareTargetWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error updating VNI %s\n%s", err, response), "ibm_is_share_mount_target", "update")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		_, err = WaitForVNIAvailable(vpcClient, *shareTarget.VirtualNetworkInterface.ID, d, d.Timeout(schema.TimeoutCreate))
 		if err != nil {
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("WaitForVNIAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 		}
 	}
 
@@ -523,16 +538,18 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 				}
 				_, response, err := vpcClient.CreateSecurityGroupTargetBinding(createsgnicoptions)
 				if err != nil {
-					return diag.FromErr(fmt.Errorf("[ERROR] Error while creating security group %q for virtual network interface of share mount target %s\n%s: %q", add[i], d.Id(), err, response))
+					tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error creating security group target binding %s\n%s", err, response), "ibm_is_share_mount_target", "update")
+					log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+					return tfErr.GetDiag()
 				}
 				_, err = WaitForVNIAvailable(vpcClient, networkID, d, d.Timeout(schema.TimeoutUpdate))
 				if err != nil {
-					return diag.FromErr(err)
+					return flex.TerraformErrorf(err, fmt.Sprintf("WaitForVNIAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 				}
 
 				_, err = WaitForTargetAvailable(context, vpcClient, shareId, mountTargetId, d, d.Timeout(schema.TimeoutUpdate))
 				if err != nil {
-					return diag.FromErr(err)
+					return flex.TerraformErrorf(err, fmt.Sprintf("WaitForTargetAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 				}
 			}
 
@@ -545,16 +562,18 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 				}
 				response, err := vpcClient.DeleteSecurityGroupTargetBinding(deletesgnicoptions)
 				if err != nil {
-					return diag.FromErr(fmt.Errorf("[ERROR] Error while removing security group %q for virtual network interface of share mount target %s\n%s: %q", remove[i], d.Id(), err, response))
+					tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error deleting security group target binding %s\n%s", err, response), "ibm_is_share_mount_target", "update")
+					log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+					return tfErr.GetDiag()
 				}
 				_, err = WaitForVNIAvailable(vpcClient, networkID, d, d.Timeout(schema.TimeoutUpdate))
 				if err != nil {
-					return diag.FromErr(err)
+					return flex.TerraformErrorf(err, fmt.Sprintf("WaitForVNIAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 				}
 
 				_, err = WaitForTargetAvailable(context, vpcClient, shareId, mountTargetId, d, d.Timeout(schema.TimeoutUpdate))
 				if err != nil {
-					return diag.FromErr(err)
+					return flex.TerraformErrorf(err, fmt.Sprintf("WaitForTargetAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 				}
 			}
 		}
@@ -563,7 +582,9 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 	if !d.IsNewResource() && (d.HasChange("virtual_network_interface.0.primary_ip.0.name") || d.HasChange("virtual_network_interface.0.primary_ip.0.auto_delete")) {
 		sess, err := meta.(conns.ClientSession).VpcV1API()
 		if err != nil {
-			return diag.FromErr(err)
+			tfErr := flex.DiscriminatedTerraformErrorf(err, err.Error(), "ibm_is_share_mount_target", "update", "initialize-client")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		subnetId := d.Get("virtual_network_interface.0.subnet").(string)
 		ripId := d.Get("virtual_network_interface.0.primary_ip.0.reserved_ip").(string)
@@ -582,34 +603,36 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 		}
 		reservedIpPathAsPatch, err := reservedIpPath.AsPatch()
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("[ERROR] Error calling reserved ip as patch \n%s", err))
+			return flex.TerraformErrorf(err, fmt.Sprintf("reservedIpPathAsPatch AsPatch failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 		}
 		updateripoptions.ReservedIPPatch = reservedIpPathAsPatch
 		_, response, err := vpcClient.UpdateSubnetReservedIP(updateripoptions)
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("[ERROR] Error updating instance network interface reserved ip(%s): %s\n%s", ripId, err, response))
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error updating reserved IP %s\n%s", err, response), "ibm_is_share_mount_target", "update")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		_, err = isWaitForReservedIpAvailable(sess, subnetId, ripId, d.Timeout(schema.TimeoutUpdate), d)
 		if err != nil {
-			return diag.FromErr(fmt.Errorf("[ERROR] Error waiting for the reserved IP to be available: %s", err))
+			return flex.TerraformErrorf(err, fmt.Sprintf("isWaitForReservedIpAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 		}
 	}
 
 	if hasChange {
 		shareTargetPatch, err := shareTargetPatchModel.AsPatch()
 		if err != nil {
-			log.Printf("[DEBUG] ShareMountTargetPatch AsPatch failed %s", err)
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("shareTargetPatch AsPatch failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 		}
 		updateShareMountTargetOptions.SetShareMountTargetPatch(shareTargetPatch)
 		_, response, err := vpcClient.UpdateShareMountTargetWithContext(context, updateShareMountTargetOptions)
 		if err != nil {
-			log.Printf("[DEBUG] UpdateShareMountTargetWithContext failed %s\n%s", err, response)
-			return diag.FromErr(err)
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Error updating share mount target %s\n%s", err, response), "ibm_is_share_mount_target", "update")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 		_, err = WaitForMountTargetAvailable(context, vpcClient, shareId, mountTargetId, d, d.Timeout(schema.TimeoutUpdate))
 		if err != nil {
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("WaitForMountTargetAvailable failed: %s", err.Error()), "ibm_is_share_mount_target", "update").GetDiag()
 		}
 	}
 
@@ -619,7 +642,11 @@ func resourceIBMIsShareMountTargetUpdate(context context.Context, d *schema.Reso
 func resourceIBMIsShareMountTargetDelete(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		if err != nil {
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_mount_target", "delete")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
+		}
 	}
 
 	deleteShareMountTargetOptions := &vpcv1.DeleteShareMountTargetOptions{}
diff --git a/ibm/service/vpc/resource_ibm_is_share_replica_operations.go b/ibm/service/vpc/resource_ibm_is_share_replica_operations.go
index e3a1d58273..8792e49ff5 100644
--- a/ibm/service/vpc/resource_ibm_is_share_replica_operations.go
+++ b/ibm/service/vpc/resource_ibm_is_share_replica_operations.go
@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/conns"
+	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/flex"
 	"github.com/IBM-Cloud/terraform-provider-ibm/ibm/validate"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"
@@ -91,7 +92,9 @@ func ResourceIbmIsShareReplicaOperationsValidator() *validate.ResourceValidator
 func resourceIbmIsShareReplicaOperationsCreate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		return diag.FromErr(err)
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_replica_operations", "create")
+		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+		return tfErr.GetDiag()
 	}
 
 	share_id := d.Get("share_replica").(string)
@@ -110,8 +113,9 @@ func resourceIbmIsShareReplicaOperationsCreate(context context.Context, d *schem
 		}
 		response, err := vpcClient.FailoverShareWithContext(context, failOverShareOptions)
 		if err != nil {
-			log.Printf("[DEBUG] FailoverShareWithContext failed %s\n%s", err, response)
-			return diag.FromErr(fmt.Errorf("[ERROR] FailoverShareWithContext failed %s\n%s", err, response))
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Fail over failed: %s\n%s", err.Error(), response), "ibm_is_share_replica_operations", "create")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 	} else {
 		deleteShareSourceOptions := &vpcv1.DeleteShareSourceOptions{
@@ -119,13 +123,14 @@ func resourceIbmIsShareReplicaOperationsCreate(context context.Context, d *schem
 		}
 		response, err := vpcClient.DeleteShareSourceWithContext(context, deleteShareSourceOptions)
 		if err != nil {
-			log.Printf("[DEBUG] DeleteShareSourceWithContext failed %s\n%s", err, response)
-			return diag.FromErr(fmt.Errorf("[ERROR] DeleteShareSourceWithContext failed %s\n%s", err, response))
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("Split share failed: %s\n%s", err.Error(), response), "ibm_is_share_replica_operations", "create")
+			log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
+			return tfErr.GetDiag()
 		}
 	}
 	_, err = isWaitForShareReplicationJobDone(context, vpcClient, share_id, d, d.Timeout(schema.TimeoutCreate))
 	if err != nil {
-		return diag.FromErr(err)
+		return flex.TerraformErrorf(err, fmt.Sprintf("isWaitForShareReplicationJobDone failed: %s", err.Error()), "ibm_is_share_replica_operations", "create").GetDiag()
 	}
 	d.SetId(share_id)
 	return nil
diff --git a/ibm/service/vpc/resource_ibm_is_share_snapshot.go b/ibm/service/vpc/resource_ibm_is_share_snapshot.go
index 13dcc0b4f5..649c97560d 100644
--- a/ibm/service/vpc/resource_ibm_is_share_snapshot.go
+++ b/ibm/service/vpc/resource_ibm_is_share_snapshot.go
@@ -318,7 +318,7 @@ func resourceIBMIsShareSnapshotCreate(context context.Context, d *schema.Resourc
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
 		// Error is coming from SDK client, so it doesn't need to be discriminated.
-		tfErr := flex.TerraformErrorf(err, err.Error(), "ibm_is_share_snapshot", "create")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_snapshot", "create")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
@@ -357,14 +357,15 @@ func resourceIBMIsShareSnapshotCreate(context context.Context, d *schema.Resourc
 	d.SetId(fmt.Sprintf("%s/%s", *createShareSnapshotOptions.ShareID, *shareSnapshot.ID))
 	_, err = isWaitForShareSnapshotAvailable(context, vpcClient, *createShareSnapshotOptions.ShareID, *shareSnapshot.ID, d, d.Timeout(schema.TimeoutCreate))
 	if err != nil {
-		return diag.FromErr(err)
+		return flex.TerraformErrorf(err, fmt.Sprintf("isWaitForShareSnapshotAvailable failed: %s", err.Error()), "ibm_is_share_snapshot", "create").GetDiag()
 	}
 	if _, ok := d.GetOk("access_tags"); ok {
 		oldList, newList := d.GetChange(isSubnetAccessTags)
 		err = flex.UpdateGlobalTagsUsingCRN(oldList, newList, meta, *shareSnapshot.CRN, "", isAccessTagType)
 		if err != nil {
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("UpdateGlobalTagsUsingCRN failed: %s", err.Error()), "ibm_is_share_snapshot", "create")
 			log.Printf(
-				"[ERROR] Error on create of resource share snapshot (%s) access tags: %s", d.Id(), err)
+				"[ERROR] Error on create of resource share snapshot (%s) access tags: %s", d.Id(), tfErr.GetDebugMessage())
 		}
 	}
 	return resourceIBMIsShareSnapshotRead(context, d, meta)
@@ -373,7 +374,7 @@ func resourceIBMIsShareSnapshotCreate(context context.Context, d *schema.Resourc
 func resourceIBMIsShareSnapshotRead(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		tfErr := flex.TerraformErrorf(err, err.Error(), "ibm_is_share_snapshot", "read")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_snapshot", "read")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
@@ -507,7 +508,7 @@ func resourceIBMIsShareSnapshotRead(context context.Context, d *schema.ResourceD
 func resourceIBMIsShareSnapshotUpdate(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		tfErr := flex.TerraformErrorf(err, err.Error(), "ibm_is_share_snapshot", "update")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_snapshot", "update")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}
@@ -579,15 +580,16 @@ func resourceIBMIsShareSnapshotUpdate(context context.Context, d *schema.Resourc
 		}
 		_, err = isWaitForShareSnapshotAvailable(context, vpcClient, parts[0], parts[1], d, d.Timeout(schema.TimeoutCreate))
 		if err != nil {
-			return diag.FromErr(err)
+			return flex.TerraformErrorf(err, fmt.Sprintf("isWaitForShareSnapshotAvailable failed: %s", err.Error()), "ibm_is_share_snapshot", "update").GetDiag()
 		}
 	}
 	if d.HasChange("access_tags") {
 		oldList, newList := d.GetChange("access_tags")
 		err := flex.UpdateGlobalTagsUsingCRN(oldList, newList, meta, d.Get(isSnapshotCRN).(string), "", isAccessTagType)
 		if err != nil {
+			tfErr := flex.TerraformErrorf(err, fmt.Sprintf("UpdateGlobalTagsUsingCRN failed: %s", err.Error()), "ibm_is_share_snapshot", "update")
 			log.Printf(
-				"[ERROR] Error on update of resource share snapshot (%s) access tags: %s", d.Id(), err)
+				"[ERROR] Error on update of resource share snapshot (%s) access tags: %s", d.Id(), tfErr)
 		}
 	}
 	return resourceIBMIsShareSnapshotRead(context, d, meta)
@@ -596,7 +598,7 @@ func resourceIBMIsShareSnapshotUpdate(context context.Context, d *schema.Resourc
 func resourceIBMIsShareSnapshotDelete(context context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
 	vpcClient, err := meta.(conns.ClientSession).VpcV1API()
 	if err != nil {
-		tfErr := flex.TerraformErrorf(err, err.Error(), "ibm_is_share_snapshot", "delete")
+		tfErr := flex.TerraformErrorf(err, fmt.Sprintf("vpcClient creation failed: %s", err.Error()), "ibm_is_share_snapshot", "delete")
 		log.Printf("[DEBUG]\n%s", tfErr.GetDebugMessage())
 		return tfErr.GetDiag()
 	}