azurerm_new_relic_monitor - support monitored_subscription property

internal/services/newrelic/client/client.go

@@ -6,14 +6,16 @@ package client
 import (
 	"fmt"
 
+	"github.com/hashicorp/go-azure-sdk/resource-manager/newrelic/2024-03-01/monitoredsubscriptions"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/newrelic/2024-03-01/monitors"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/newrelic/2024-03-01/tagrules"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/common"
 )
 
 type Client struct {
-	MonitorsClient *monitors.MonitorsClient
-	TagRulesClient *tagrules.TagRulesClient
+	MonitorsClient               *monitors.MonitorsClient
+	MonitoredSubscriptionsClient *monitoredsubscriptions.MonitoredSubscriptionsClient
+	TagRulesClient               *tagrules.TagRulesClient
 }
 
 func NewClient(o *common.ClientOptions) (*Client, error) {
@@ -24,6 +26,13 @@ func NewClient(o *common.ClientOptions) (*Client, error) {
 
 	o.Configure(monitorsClient.Client, o.Authorizers.ResourceManager)
 
+	monitoredSubscriptionsClient, err := monitoredsubscriptions.NewMonitoredSubscriptionsClientWithBaseURI(o.Environment.ResourceManager)
+	if err != nil {
+		return nil, fmt.Errorf("building Monitored Subscriptions client: %+v", err)
+	}
+
+	o.Configure(monitoredSubscriptionsClient.Client, o.Authorizers.ResourceManager)
+
 	tagRulesClient, err := tagrules.NewTagRulesClientWithBaseURI(o.Environment.ResourceManager)
 	if err != nil {
 		return nil, fmt.Errorf("building TagRules client: %+v", err)
@@ -32,7 +41,8 @@ func NewClient(o *common.ClientOptions) (*Client, error) {
 	o.Configure(tagRulesClient.Client, o.Authorizers.ResourceManager)
 
 	return &Client{
-		MonitorsClient: monitorsClient,
-		TagRulesClient: tagRulesClient,
+		MonitorsClient:               monitorsClient,
+		MonitoredSubscriptionsClient: monitoredSubscriptionsClient,
+		TagRulesClient:               tagRulesClient,
 	}, nil
 }

internal/services/newrelic/new_relic_monitor_resource.go

@@ -15,6 +15,7 @@ import (
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/commonschema"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/identity"
 	"github.com/hashicorp/go-azure-helpers/resourcemanager/location"
+	"github.com/hashicorp/go-azure-sdk/resource-manager/newrelic/2024-03-01/monitoredsubscriptions"
 	"github.com/hashicorp/go-azure-sdk/resource-manager/newrelic/2024-03-01/monitors"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/sdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
@@ -27,17 +28,22 @@ const (
 )
 
 type NewRelicMonitorModel struct {
-	Name                  string                         `tfschema:"name"`
-	ResourceGroupName     string                         `tfschema:"resource_group_name"`
-	AccountCreationSource monitors.AccountCreationSource `tfschema:"account_creation_source"`
-	AccountId             string                         `tfschema:"account_id"`
-	IngestionKey          string                         `tfschema:"ingestion_key"`
-	Location              string                         `tfschema:"location"`
-	OrganizationId        string                         `tfschema:"organization_id"`
-	OrgCreationSource     monitors.OrgCreationSource     `tfschema:"org_creation_source"`
-	PlanData              []PlanDataModel                `tfschema:"plan"`
-	UserId                string                         `tfschema:"user_id"`
-	UserInfo              []UserInfoModel                `tfschema:"user"`
+	Name                  string                          `tfschema:"name"`
+	ResourceGroupName     string                          `tfschema:"resource_group_name"`
+	AccountCreationSource monitors.AccountCreationSource  `tfschema:"account_creation_source"`
+	AccountId             string                          `tfschema:"account_id"`
+	IngestionKey          string                          `tfschema:"ingestion_key"`
+	Location              string                          `tfschema:"location"`
+	MonitoredSubscription []NewRelicMonitoredSubscription `tfschema:"monitored_subscription"`
+	OrganizationId        string                          `tfschema:"organization_id"`
+	OrgCreationSource     monitors.OrgCreationSource      `tfschema:"org_creation_source"`
+	PlanData              []PlanDataModel                 `tfschema:"plan"`
+	UserId                string                          `tfschema:"user_id"`
+	UserInfo              []UserInfoModel                 `tfschema:"user"`
+}
+
+type NewRelicMonitoredSubscription struct {
+	SubscriptionId string `tfschema:"subscription_id"`
 }
 
 type PlanDataModel struct {
@@ -56,7 +62,10 @@ type UserInfoModel struct {
 
 type NewRelicMonitorResource struct{}
 
-var _ sdk.Resource = NewRelicMonitorResource{}
+var (
+	_ sdk.Resource           = NewRelicMonitorResource{}
+	_ sdk.ResourceWithUpdate = NewRelicMonitorResource{}
+)
 
 func (r NewRelicMonitorResource) ResourceType() string {
 	return "azurerm_new_relic_monitor"
@@ -205,6 +214,20 @@ func (r NewRelicMonitorResource) Arguments() map[string]*pluginsdk.Schema {
 			ValidateFunc: validation.StringIsNotEmpty,
 		},
 
+		"monitored_subscription": {
+			Type:     pluginsdk.TypeList,
+			Optional: true,
+			Elem: &pluginsdk.Resource{
+				Schema: map[string]*pluginsdk.Schema{
+					"subscription_id": {
+						Type:         pluginsdk.TypeString,
+						Required:     true,
+						ValidateFunc: validation.IsUUID,
+					},
+				},
+			},
+		},
+
 		"organization_id": {
 			Type:         pluginsdk.TypeString,
 			Optional:     true,
@@ -282,7 +305,21 @@ func (r NewRelicMonitorResource) Create() sdk.ResourceFunc {
 				return fmt.Errorf("creating %s: %+v", id, err)
 			}
 
+			if len(model.MonitoredSubscription) > 0 {
+				monitoredSubscriptionsProperties := monitoredsubscriptions.MonitoredSubscriptionProperties{
+					Properties: &monitoredsubscriptions.SubscriptionList{
+						MonitoredSubscriptionList: expandMonitorSubscriptionList(model.MonitoredSubscription),
+					},
+				}
+
+				monitorId := monitoredsubscriptions.NewMonitorID(id.SubscriptionId, id.ResourceGroupName, id.MonitorName)
+				if err := metadata.Client.NewRelic.MonitoredSubscriptionsClient.CreateOrUpdateThenPoll(ctx, monitorId, monitoredSubscriptionsProperties); err != nil {
+					return fmt.Errorf("creating NewRelic Monitored Subscriptions of %s: %+v", id, err)
+				}
+			}
+
 			metadata.SetID(id)
+
 			return nil
 		},
 	}
@@ -352,11 +389,62 @@ func (r NewRelicMonitorResource) Read() sdk.ResourceFunc {
 				state.UserInfo = flattenUserInfoModel(properties.UserInfo)
 			}
 
+			monitorId := monitoredsubscriptions.NewMonitorID(id.SubscriptionId, id.ResourceGroupName, id.MonitorName)
+			monitoredSubscriptionResp, err := metadata.Client.NewRelic.MonitoredSubscriptionsClient.Get(ctx, monitorId)
+			if err != nil && !response.WasNotFound(monitoredSubscriptionResp.HttpResponse) {
+				return fmt.Errorf("retrieving NewRelic Monitored Subscriptions of %s: %+v", *id, err)
+			}
+			if !response.WasNotFound(monitoredSubscriptionResp.HttpResponse) {
+				if monitoredSubscriptionResp.Model != nil && monitoredSubscriptionResp.Model.Properties != nil {
+					state.MonitoredSubscription = flattenMonitorSubscriptionList(monitoredSubscriptionResp.Model.Properties.MonitoredSubscriptionList)
+				}
+			}
+
 			return metadata.Encode(&state)
 		},
 	}
 }
 
+func (r NewRelicMonitorResource) Update() sdk.ResourceFunc {
+	return sdk.ResourceFunc{
+		Timeout: 30 * time.Minute,
+		Func: func(ctx context.Context, metadata sdk.ResourceMetaData) error {
+			id, err := monitors.ParseMonitorID(metadata.ResourceData.Id())
+			if err != nil {
+				return err
+			}
+
+			var originalModel NewRelicMonitorModel
+			if err = metadata.Decode(&originalModel); err != nil {
+				return fmt.Errorf("decoding: %+v", err)
+			}
+
+			if metadata.ResourceData.HasChange("monitored_subscription") {
+				monitoredSubscriptionsClient := metadata.Client.NewRelic.MonitoredSubscriptionsClient
+				monitorId := monitoredsubscriptions.NewMonitorID(id.SubscriptionId, id.ResourceGroupName, id.MonitorName)
+
+				if len(originalModel.MonitoredSubscription) == 0 {
+					if _, err := monitoredSubscriptionsClient.Delete(ctx, monitorId); err != nil {
+						return fmt.Errorf("deleting NewRelic Monitored Subscriptions of %s: %+v", *id, err)
+					}
+				} else {
+					monitoredSubscriptionsProperties := monitoredsubscriptions.MonitoredSubscriptionProperties{
+						Properties: &monitoredsubscriptions.SubscriptionList{
+							MonitoredSubscriptionList: expandMonitorSubscriptionList(originalModel.MonitoredSubscription),
+						},
+					}
+
+					if err := monitoredSubscriptionsClient.CreateOrUpdateThenPoll(ctx, monitorId, monitoredSubscriptionsProperties); err != nil {
+						return fmt.Errorf("updating NewRelic Monitored Subscriptions of %s: %+v", *id, err)
+					}
+				}
+			}
+
+			return nil
+		},
+	}
+}
+
 func (r NewRelicMonitorResource) Delete() sdk.ResourceFunc {
 	return sdk.ResourceFunc{
 		Timeout: 30 * time.Minute,
@@ -377,7 +465,7 @@ func (r NewRelicMonitorResource) Delete() sdk.ResourceFunc {
 			}
 
 			if err = client.DeleteThenPoll(ctx, *id, monitors.DeleteOperationOptions{UserEmail: &model.UserInfo[0].EmailAddress}); err != nil {
-				return fmt.Errorf("deleting %s: %+v", id, err)
+				return fmt.Errorf("deleting %s: %+v", *id, err)
 			}
 
 			return nil
@@ -537,3 +625,34 @@ func flattenUserInfoModel(input *monitors.UserInfo) []UserInfoModel {
 
 	return append(outputList, output)
 }
+
+func expandMonitorSubscriptionList(input []NewRelicMonitoredSubscription) *[]monitoredsubscriptions.MonitoredSubscription {
+	results := make([]monitoredsubscriptions.MonitoredSubscription, 0)
+	if len(input) == 0 {
+		return &results
+	}
+
+	for _, v := range input {
+		results = append(results, monitoredsubscriptions.MonitoredSubscription{
+			SubscriptionId: pointer.To(v.SubscriptionId),
+		})
+	}
+
+	return &results
+}
+
+func flattenMonitorSubscriptionList(input *[]monitoredsubscriptions.MonitoredSubscription) []NewRelicMonitoredSubscription {
+	results := make([]NewRelicMonitoredSubscription, 0)
+	if input == nil {
+		return results
+	}
+
+	for _, v := range *input {
+		results = append(results, NewRelicMonitoredSubscription{
+			// The returned subscription UUID is in upper case
+			SubscriptionId: strings.ToLower(pointer.From(v.SubscriptionId)),
+		})
+	}
+
+	return results
+}

internal/services/newrelic/new_relic_monitor_resource_test.go

@@ -98,6 +98,52 @@ func TestAccNewRelicMonitor_identity(t *testing.T) {
 	})
 }
 
+func TestAccNewRelicMonitor_monitoredSubscription(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_new_relic_monitor", "test")
+	r := NewRelicMonitorResource{}
+	effectiveDate := time.Now().Add(time.Hour * 7).Format(time.RFC3339)
+	email := "[email protected]"
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.monitoredSubscription(data, effectiveDate, email),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
+func TestAccNewRelicMonitor_monitoredSubscriptionUpdate(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_new_relic_monitor", "test")
+	r := NewRelicMonitorResource{}
+	effectiveDate := time.Now().Add(time.Hour * 7).Format(time.RFC3339)
+	email := "[email protected]"
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.basic(data, effectiveDate, email),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+		{
+			Config: r.monitoredSubscription(data, effectiveDate, email),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+		{
+			Config: r.basic(data, effectiveDate, email),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
 func (r NewRelicMonitorResource) Exists(ctx context.Context, clients *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
 	id, err := monitors.ParseMonitorID(state.ID)
 	if err != nil {
@@ -247,3 +293,35 @@ resource "azurerm_role_assignment" "test" {
 }
 `, template, data.RandomInteger, data.Locations.Primary, effectiveDate, email)
 }
+
+func (r NewRelicMonitorResource) monitoredSubscription(data acceptance.TestData, effectiveDate string, email string) string {
+	template := r.template(data)
+	return fmt.Sprintf(`
+%s
+
+data "azurerm_subscription" "test" {
+  subscription_id = "%s"
+}
+
+resource "azurerm_new_relic_monitor" "test" {
+  name                = "acctest-nrm-%d"
+  resource_group_name = azurerm_resource_group.test.name
+  location            = "%s"
+  plan {
+    effective_date = "%s"
+  }
+  user {
+    email        = "%s"
+    first_name   = "first"
+    last_name    = "last"
+    phone_number = "123456"
+  }
+  identity {
+    type = "SystemAssigned"
+  }
+  monitored_subscription {
+    subscription_id = data.azurerm_subscription.test.subscription_id
+  }
+}
+`, template, data.Subscriptions.Secondary, data.RandomInteger, data.Locations.Primary, effectiveDate, email)
+}