compute: add request_headers and response_headers to log_config on backend service (#18293) (#12746)

[upstream:54fe8076326bbe4efd31438f995fb55f36e541e6]

Signed-off-by: Modular Magician <magic-modules@google.com>

Author: modular-magician

.changelog/18293.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added `request_headers` and `response_headers` fields to `log_config` on `google_compute_backend_service` and `google_compute_region_backend_service` resources
+```

google-beta/services/compute/resource_compute_backend_service.go

@@ -1076,6 +1076,34 @@ For example: orca_load_report, tls.protocol`,
 Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM. Possible values: ["INCLUDE_ALL_OPTIONAL", "EXCLUDE_ALL_OPTIONAL", "CUSTOM"]`,
 							AtLeastOneOf: []string{"log_config.0.enable", "log_config.0.optional_mode", "log_config.0.sample_rate"},
 						},
+						"request_headers": {
+							Type:        schema.TypeList,
+							Optional:    true,
+							Description: `This field can only be specified if logging is enabled for this backend service and if the BackendService protocol is one of HTTP, HTTPS, HTTP2 and GRPC. Contains a list of request headers to be logged.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"header_name": {
+										Type:        schema.TypeString,
+										Required:    true,
+										Description: `The header name to match on for logging.`,
+									},
+								},
+							},
+						},
+						"response_headers": {
+							Type:        schema.TypeList,
+							Optional:    true,
+							Description: `This field can only be specified if logging is enabled for this backend service and if the BackendService protocol is one of HTTP, HTTPS, HTTP2 and GRPC. Contains a list of response headers to be logged.`,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"header_name": {
+										Type:        schema.TypeString,
+										Required:    true,
+										Description: `The header name to match on for logging.`,
+									},
+								},
+							},
+						},
 						"sample_rate": {
 							Type:             schema.TypeFloat,
 							Optional:         true,
@@ -4214,6 +4242,10 @@ func flattenComputeBackendServiceLogConfig(v interface{}, d *schema.ResourceData
 		flattenComputeBackendServiceLogConfigOptionalMode(original["optionalMode"], d, config)
 	transformed["optional_fields"] =
 		flattenComputeBackendServiceLogConfigOptionalFields(original["optionalFields"], d, config)
+	transformed["request_headers"] =
+		flattenComputeBackendServiceLogConfigRequestHeaders(original["loggingHttpRequestHeaders"], d, config)
+	transformed["response_headers"] =
+		flattenComputeBackendServiceLogConfigResponseHeaders(original["loggingHttpResponseHeaders"], d, config)
 	return []interface{}{transformed}
 }
 func flattenComputeBackendServiceLogConfigEnable(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
@@ -4232,6 +4264,50 @@ func flattenComputeBackendServiceLogConfigOptionalFields(v interface{}, d *schem
 	return v
 }
 
+func flattenComputeBackendServiceLogConfigRequestHeaders(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return v
+	}
+	l := v.([]interface{})
+	transformed := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		original := raw.(map[string]interface{})
+		if len(original) < 1 {
+			// Do not include empty json objects coming back from the api
+			continue
+		}
+		transformed = append(transformed, map[string]interface{}{
+			"header_name": flattenComputeBackendServiceLogConfigRequestHeadersHeaderName(original["headerName"], d, config),
+		})
+	}
+	return transformed
+}
+func flattenComputeBackendServiceLogConfigRequestHeadersHeaderName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
+func flattenComputeBackendServiceLogConfigResponseHeaders(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	if v == nil {
+		return v
+	}
+	l := v.([]interface{})
+	transformed := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		original := raw.(map[string]interface{})
+		if len(original) < 1 {
+			// Do not include empty json objects coming back from the api
+			continue
+		}
+		transformed = append(transformed, map[string]interface{}{
+			"header_name": flattenComputeBackendServiceLogConfigResponseHeadersHeaderName(original["headerName"], d, config),
+		})
+	}
+	return transformed
+}
+func flattenComputeBackendServiceLogConfigResponseHeadersHeaderName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func flattenComputeBackendServiceServiceLbPolicy(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
 	return v
 }
@@ -5888,6 +5964,20 @@ func expandComputeBackendServiceLogConfig(v interface{}, d tpgresource.Terraform
 		transformed["optionalFields"] = transformedOptionalFields
 	}
 
+	transformedRequestHeaders, err := expandComputeBackendServiceLogConfigRequestHeaders(original["request_headers"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedRequestHeaders); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["loggingHttpRequestHeaders"] = transformedRequestHeaders
+	}
+
+	transformedResponseHeaders, err := expandComputeBackendServiceLogConfigResponseHeaders(original["response_headers"], d, config)
+	if err != nil {
+		return nil, err
+	} else if val := reflect.ValueOf(transformedResponseHeaders); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+		transformed["loggingHttpResponseHeaders"] = transformedResponseHeaders
+	}
+
 	return transformed, nil
 }
 
@@ -5907,6 +5997,64 @@ func expandComputeBackendServiceLogConfigOptionalFields(v interface{}, d tpgreso
 	return v, nil
 }
 
+func expandComputeBackendServiceLogConfigRequestHeaders(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	if v == nil {
+		return nil, nil
+	}
+	l := v.([]interface{})
+	req := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		if raw == nil {
+			continue
+		}
+		original := raw.(map[string]interface{})
+		transformed := make(map[string]interface{})
+
+		transformedHeaderName, err := expandComputeBackendServiceLogConfigRequestHeadersHeaderName(original["header_name"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedHeaderName); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["headerName"] = transformedHeaderName
+		}
+
+		req = append(req, transformed)
+	}
+	return req, nil
+}
+
+func expandComputeBackendServiceLogConfigRequestHeadersHeaderName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
+func expandComputeBackendServiceLogConfigResponseHeaders(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	if v == nil {
+		return nil, nil
+	}
+	l := v.([]interface{})
+	req := make([]interface{}, 0, len(l))
+	for _, raw := range l {
+		if raw == nil {
+			continue
+		}
+		original := raw.(map[string]interface{})
+		transformed := make(map[string]interface{})
+
+		transformedHeaderName, err := expandComputeBackendServiceLogConfigResponseHeadersHeaderName(original["header_name"], d, config)
+		if err != nil {
+			return nil, err
+		} else if val := reflect.ValueOf(transformedHeaderName); val.IsValid() && !tpgresource.IsEmptyValue(val) {
+			transformed["headerName"] = transformedHeaderName
+		}
+
+		req = append(req, transformed)
+	}
+	return req, nil
+}
+
+func expandComputeBackendServiceLogConfigResponseHeadersHeaderName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeBackendServiceServiceLbPolicy(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }

google-beta/services/compute/resource_compute_backend_service_generated_meta.yaml

@@ -108,6 +108,10 @@ fields:
     - api_field: logConfig.enable
     - api_field: logConfig.optionalFields
     - api_field: logConfig.optionalMode
+    - api_field: logConfig.loggingHttpRequestHeaders.headerName
+      field: log_config.request_headers.header_name
+    - api_field: logConfig.loggingHttpResponseHeaders.headerName
+      field: log_config.response_headers.header_name
     - api_field: logConfig.sampleRate
     - api_field: maxStreamDuration.nanos
     - api_field: maxStreamDuration.seconds

google-beta/services/compute/resource_compute_backend_service_test.go

@@ -875,6 +875,37 @@ func TestAccComputeBackendService_withLogConfigMode(t *testing.T) {
 	})
 }
 
+func TestAccComputeBackendService_withLogConfigRequestResponseHeaders(t *testing.T) {
+	t.Parallel()
+
+	serviceName := fmt.Sprintf("tf-test-lc-%s", acctest.RandString(t, 10))
+	checkName := fmt.Sprintf("tf-test-lc-%s", acctest.RandString(t, 10))
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeBackendServiceDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeBackendService_withLogConfigRequestResponseHeaders(serviceName, checkName, "X-Request-Id", "X-Response-Id"),
+			},
+			{
+				ResourceName:      "google_compute_backend_service.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccComputeBackendService_withLogConfigRequestResponseHeaders(serviceName, checkName, "X-Request-Id-Updated", "X-Response-Id-Updated"),
+			},
+			{
+				ResourceName:      "google_compute_backend_service.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func TestAccComputeBackendService_trafficDirectorUpdateBasic(t *testing.T) {
 	t.Parallel()
 
@@ -2526,6 +2557,38 @@ resource "google_compute_health_check" "zero" {
 `, serviceName, enabled, mode, checkName)
 }
 
+func testAccComputeBackendService_withLogConfigRequestResponseHeaders(serviceName, checkName, reqHeader, respHeader string) string {
+	return fmt.Sprintf(`
+resource "google_compute_backend_service" "foobar" {
+  name                  = "%s"
+  protocol              = "HTTP"
+  load_balancing_scheme = "INTERNAL_MANAGED"
+  health_checks         = [google_compute_health_check.zero.self_link]
+
+  log_config {
+    enable      = true
+    sample_rate = 0.5
+    request_headers {
+      header_name = "%s"
+    }
+    response_headers {
+      header_name = "%s"
+    }
+  }
+}
+
+resource "google_compute_health_check" "zero" {
+  name               = "%s"
+  check_interval_sec = 1
+  timeout_sec        = 1
+
+  http_health_check {
+    port = 80
+  }
+}
+`, serviceName, reqHeader, respHeader, checkName)
+}
+
 func testAccComputeBackendService_withCompressionMode(serviceName, checkName, compressionMode string) string {
 	return fmt.Sprintf(`
 resource "google_compute_backend_service" "foobar" {