Promote singleInstanceAssignment and filter to GA (#13250) (#21760)

[upstream:72e30993f29eb7e86d583bf1631a955deffc6bf6]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/13250.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: promote fields `singleInstanceAssignment` and `filter` to GA for `google_compute_autoscaler` resource
+```

google/services/compute/resource_compute_autoscaler.go

@@ -170,6 +170,63 @@ be a positive float value. If not defined, the default is 0.8.`,
 The metric cannot have negative values.
 
 The metric must have a value type of INT64 or DOUBLE.`,
+									},
+									"filter": {
+										Type:     schema.TypeString,
+										Optional: true,
+										Description: `A filter string to be used as the filter string for
+a Stackdriver Monitoring TimeSeries.list API call.
+This filter is used to select a specific TimeSeries for
+the purpose of autoscaling and to determine whether the metric
+is exporting per-instance or per-group data.
+
+You can only use the AND operator for joining selectors.
+You can only use direct equality comparison operator (=) without
+any functions for each selector.
+You can specify the metric in both the filter string and in the
+metric field. However, if specified in both places, the metric must
+be identical.
+
+The monitored resource type determines what kind of values are
+expected for the metric. If it is a gce_instance, the autoscaler
+expects the metric to include a separate TimeSeries for each
+instance in a group. In such a case, you cannot filter on resource
+labels.
+
+If the resource type is any other value, the autoscaler expects
+this metric to contain values that apply to the entire autoscaled
+instance group and resource label filtering can be performed to
+point autoscaler at the correct TimeSeries to scale upon.
+This is called a per-group metric for the purpose of autoscaling.
+
+If not specified, the type defaults to gce_instance.
+
+You should provide a filter that is selective enough to pick just
+one TimeSeries for the autoscaled group or for each of the instances
+(if you are using gce_instance resource type). If multiple
+TimeSeries are returned upon the query execution, the autoscaler
+will sum their respective values to obtain its scaling value.`,
+										Default: "resource.type = gce_instance",
+									},
+									"single_instance_assignment": {
+										Type:     schema.TypeFloat,
+										Optional: true,
+										Description: `If scaling is based on a per-group metric value that represents the
+total amount of work to be done or resource usage, set this value to
+an amount assigned for a single instance of the scaled group.
+The autoscaler will keep the number of instances proportional to the
+value of this metric, the metric itself should not change value due
+to group resizing.
+
+For example, a good metric to use with the target is
+'pubsub.googleapis.com/subscription/num_undelivered_messages'
+or a custom metric exporting the total number of requests coming to
+your instances.
+
+A bad example would be a metric exporting an average or median
+latency, since this value can't include a chunk assignable to a
+single instance, it could be better used with utilization_target
+instead.`,
 									},
 									"target": {
 										Type:     schema.TypeFloat,
@@ -890,9 +947,11 @@ func flattenComputeAutoscalerAutoscalingPolicyMetric(v interface{}, d *schema.Re
 			continue
 		}
 		transformed = append(transformed, map[string]interface{}{
-			"name":   flattenComputeAutoscalerAutoscalingPolicyMetricName(original["metric"], d, config),
-			"target": flattenComputeAutoscalerAutoscalingPolicyMetricTarget(original["utilizationTarget"], d, config),
-			"type":   flattenComputeAutoscalerAutoscalingPolicyMetricType(original["utilizationTargetType"], d, config),
+			"name":                       flattenComputeAutoscalerAutoscalingPolicyMetricName(original["metric"], d, config),
+			"single_instance_assignment": flattenComputeAutoscalerAutoscalingPolicyMetricSingleInstanceAssignment(original["singleInstanceAssignment"], d, config),
+			"target":                     flattenComputeAutoscalerAutoscalingPolicyMetricTarget(original["utilizationTarget"], d, config),
+			"type":                       flattenComputeAutoscalerAutoscalingPolicyMetricType(original["utilizationTargetType"], d, config),
+			"filter":                     flattenComputeAutoscalerAutoscalingPolicyMetricFilter(original["filter"], d, config),
 		})
 	}
 	return transformed
@@ -901,6 +960,10 @@ func flattenComputeAutoscalerAutoscalingPolicyMetricName(v interface{}, d *schem
 	return v
 }
 
+func flattenComputeAutoscalerAutoscalingPolicyMetricSingleInstanceAssignment(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeAutoscalerAutoscalingPolicyMetricTarget(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	return v
 }
@@ -909,6 +972,10 @@ func flattenComputeAutoscalerAutoscalingPolicyMetricType(v interface{}, d *schem
 	return v
 }
 
+func flattenComputeAutoscalerAutoscalingPolicyMetricFilter(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeAutoscalerAutoscalingPolicyLoadBalancingUtilization(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	if v == nil {
 		return nil
@@ -1217,6 +1284,13 @@ func expandComputeAutoscalerAutoscalingPolicyMetric(v interface{}, d tpgresource
 			transformed["metric"] = transformedName
 		}
 
+		transformedSingleInstanceAssignment, err := expandComputeAutoscalerAutoscalingPolicyMetricSingleInstanceAssignment(original["single_instance_assignment"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedSingleInstanceAssignment); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["singleInstanceAssignment"] = transformedSingleInstanceAssignment
+		}
+
 		transformedTarget, err := expandComputeAutoscalerAutoscalingPolicyMetricTarget(original["target"], d, config)
 		if err != nil {
 			return nil, err
@@ -1231,6 +1305,13 @@ func expandComputeAutoscalerAutoscalingPolicyMetric(v interface{}, d tpgresource
 			transformed["utilizationTargetType"] = transformedType
 		}
 
+		transformedFilter, err := expandComputeAutoscalerAutoscalingPolicyMetricFilter(original["filter"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedFilter); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["filter"] = transformedFilter
+		}
+
 		req = append(req, transformed)
 	}
 	return req, nil
@@ -1240,6 +1321,10 @@ func expandComputeAutoscalerAutoscalingPolicyMetricName(v interface{}, d tpgreso
 	return v, nil
 }
 
+func expandComputeAutoscalerAutoscalingPolicyMetricSingleInstanceAssignment(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeAutoscalerAutoscalingPolicyMetricTarget(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
@@ -1248,6 +1333,10 @@ func expandComputeAutoscalerAutoscalingPolicyMetricType(v interface{}, d tpgreso
 	return v, nil
 }
 
+func expandComputeAutoscalerAutoscalingPolicyMetricFilter(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeAutoscalerAutoscalingPolicyLoadBalancingUtilization(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	l := v.([]interface{})
 	if len(l) == 0 || l[0] == nil {

google/services/compute/resource_compute_autoscaler_generated_meta.yaml

@@ -14,8 +14,12 @@ fields:
     api_field: 'autoscaling_policy.load_balancing_utilization.utilization_target'
   - field: 'autoscaling_policy.max_replicas'
     api_field: 'autoscaling_policy.max_num_replicas'
+  - field: 'autoscaling_policy.metric.filter'
+    api_field: 'autoscaling_policy.custom_metric_utilizations.filter'
   - field: 'autoscaling_policy.metric.name'
     api_field: 'autoscaling_policy.custom_metric_utilizations.metric'
+  - field: 'autoscaling_policy.metric.single_instance_assignment'
+    api_field: 'autoscaling_policy.custom_metric_utilizations.single_instance_assignment'
   - field: 'autoscaling_policy.metric.target'
     api_field: 'autoscaling_policy.custom_metric_utilizations.utilization_target'
   - field: 'autoscaling_policy.metric.type'

website/docs/r/compute_autoscaler.html.markdown

@@ -370,7 +370,7 @@ The following arguments are supported:
   The metric must have a value type of INT64 or DOUBLE.
 
 * `single_instance_assignment` -
-  (Optional, [Beta](https://terraform.io/docs/providers/google/guides/provider_versions.html))
+  (Optional)
   If scaling is based on a per-group metric value that represents the
   total amount of work to be done or resource usage, set this value to
   an amount assigned for a single instance of the scaled group.
@@ -404,7 +404,7 @@ The following arguments are supported:
   Possible values are: `GAUGE`, `DELTA_PER_SECOND`, `DELTA_PER_MINUTE`.
 
 * `filter` -
-  (Optional, [Beta](https://terraform.io/docs/providers/google/guides/provider_versions.html))
+  (Optional)
   A filter string to be used as the filter string for
   a Stackdriver Monitoring TimeSeries.list API call.
   This filter is used to select a specific TimeSeries for