fix(sidekick/rust): Ensure detailed-tracing-attributes flag is fully propagated (#2438)

This commit fixes the propagation of the `detailed-tracing-attributes`
flag to all necessary annotation structs and updates the templates to
correctly utilize the flag. See #2435 and #2252

For googleapis/google-cloud-rust#3239

Specifically:
- Adds `DetailedTracingAttributes` field to `modelAnnotations` and
`serviceAnnotations` in `annotate.go` to make the flag accessible in
`lib.rs.mustache` and service-level sections of `transport.rs.mustache`.
- Updates `annotateModel` and `annotateService` to populate the new
fields.
- Adds comprehensive unit tests in `annotate_test.go` to verify the
`DetailedTracingAttributes` flag is correctly set across
`modelAnnotations`, `serviceAnnotations`, `methodAnnotation`, and
`pathBindingAnnotation` based on the codec options.
- Modifies `lib.rs.mustache` to initialize the static
`INSTRUMENTATION_CLIENT_INFO` using `std::sync::LazyLock` to accommodate
the non-const `default()` function.
- Updates `transport.rs.mustache` to correctly dereference the
`LazyLock` when calling `with_instrumentation` (i.e.,
`&*crate::info::INSTRUMENTATION_CLIENT_INFO`).

These changes ensure that the conditional code blocks in both
`lib.rs.mustache` and `transport.rs.mustache` related to detailed
tracing are generated correctly based on the
`detailed-tracing-attributes` flag.

Tested:
- Ran `go test -race ./...` in the librarian repository to ensure all
unit tests pass, including new tests for flag propagation in
annotations.
- Manually regenerated the `google-cloud-showcase-v1beta1` client in a
local `google-cloud-rust` clone using the modified librarian:
1. With `--codec-option=detailed-tracing-attributes=true`: - Verified
`src/generated/showcase/src/lib.rs` contains the
`INSTRUMENTATION_CLIENT_INFO` static (using `LazyLock`). - Verified
`src/generated/showcase/src/transport.rs` includes
`.with_instrumentation(&*crate::info::INSTRUMENTATION_CLIENT_INFO)`
calls within the `if tracing_is_enabled` blocks in the `new` methods. -
Confirmed the crate builds and tests pass: `cargo build -p
google-cloud-showcase-v1beta1` `cargo test -p
google-cloud-showcase-v1beta1`
    2.  With the flag off (default):
        - Verified the above tracing-specific code is absent.
3. By setting `detailed-tracing-attributes = "true"` in
`src/generated/showcase/.sidekick.toml` and running refresh without the
codec option, confirming the config file is also respected.

Author: westarle

internal/sidekick/internal/rust/annotate.go

@@ -57,6 +57,9 @@ type modelAnnotations struct {
 	Incomplete bool
 	// If true, the generator will produce reference documentation samples for message fields setters.
 	GenerateSetterSamples bool
+	// If true, the generated code includes detailed tracing attributes on HTTP
+	// requests.
+	DetailedTracingAttributes bool
 }
 
 // IsWktCrate returns true when bootstrapping the well-known types crate the templates add some
@@ -107,6 +110,9 @@ type serviceAnnotations struct {
 	HasVeneer bool
 	// If true, the service has a method we cannot wrap (yet).
 	Incomplete bool
+	// If true, the generated code includes detailed tracing attributes on HTTP
+	// requests.
+	DetailedTracingAttributes bool
 }
 
 // HasBindingSubstitutions returns true if the method has binding substitutions.
@@ -554,7 +560,8 @@ func annotateModel(model *api.API, codec *codec) *modelAnnotations {
 		Incomplete: slices.ContainsFunc(model.Services, func(s *api.Service) bool {
 			return slices.ContainsFunc(s.Methods, func(m *api.Method) bool { return !codec.generateMethod(m) })
 		}),
-		GenerateSetterSamples: codec.generateSetterSamples,
+		GenerateSetterSamples:     codec.generateSetterSamples,
+		DetailedTracingAttributes: codec.detailedTracingAttributes,
 	}
 
 	codec.addFeatureAnnotations(model, ann)
@@ -668,13 +675,14 @@ func (c *codec) annotateService(s *api.Service) {
 		ModuleName:        moduleName,
 		DocLines: c.formatDocComments(
 			s.Documentation, s.ID, s.Model.State, []string{s.ID, s.Package}),
-		Methods:            methods,
-		DefaultHost:        s.DefaultHost,
-		LROTypes:           lroTypes,
-		APITitle:           s.Model.Title,
-		PerServiceFeatures: c.perServiceFeatures,
-		HasVeneer:          c.hasVeneer,
-		Incomplete:         slices.ContainsFunc(s.Methods, func(m *api.Method) bool { return !c.generateMethod(m) }),
+		Methods:                   methods,
+		DefaultHost:               s.DefaultHost,
+		LROTypes:                  lroTypes,
+		APITitle:                  s.Model.Title,
+		PerServiceFeatures:        c.perServiceFeatures,
+		HasVeneer:                 c.hasVeneer,
+		Incomplete:                slices.ContainsFunc(s.Methods, func(m *api.Method) bool { return !c.generateMethod(m) }),
+		DetailedTracingAttributes: c.detailedTracingAttributes,
 	}
 	s.Codec = ann
 }

internal/sidekick/internal/rust/annotate_test.go

@@ -216,6 +216,44 @@ func TestServiceAnnotations(t *testing.T) {
 	}
 }
 
+func TestServiceAnnotationsDetailedTracing(t *testing.T) {
+	model := serviceAnnotationsModel()
+	service, ok := model.State.ServiceByID[".test.v1.ResourceService"]
+	if !ok {
+		t.Fatal("cannot find .test.v1.ResourceService")
+	}
+	codec, err := newCodec("protobuf", map[string]string{
+		"detailed-tracing-attributes": "true",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	annotateModel(model, codec)
+	got := service.Codec.(*serviceAnnotations)
+	if !got.DetailedTracingAttributes {
+		t.Errorf("serviceAnnotations.DetailedTracingAttributes = %v, want %v", got.DetailedTracingAttributes, true)
+	}
+}
+
+func TestMethodAnnotationsDetailedTracing(t *testing.T) {
+	model := serviceAnnotationsModel()
+	method, ok := model.State.MethodByID[".test.v1.ResourceService.GetResource"]
+	if !ok {
+		t.Fatal("cannot find .test.v1.ResourceService.GetResource")
+	}
+	codec, err := newCodec("protobuf", map[string]string{
+		"detailed-tracing-attributes": "true",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	annotateModel(model, codec)
+	got := method.Codec.(*methodAnnotation)
+	if !got.DetailedTracingAttributes {
+		t.Errorf("methodAnnotation.DetailedTracingAttributes = %v, want %v", got.DetailedTracingAttributes, true)
+	}
+}
+
 func TestServiceAnnotationsPerServiceFeatures(t *testing.T) {
 	model := serviceAnnotationsModel()
 	service, ok := model.State.ServiceByID[".test.v1.ResourceService"]
@@ -1120,7 +1158,6 @@ func TestPathBindingAnnotations(t *testing.T) {
 			},
 		},
 	}
-
 	b2 := &api.PathBinding{
 		Verb: "POST",
 		PathTemplate: api.NewPathTemplate().
@@ -1153,7 +1190,6 @@ func TestPathBindingAnnotations(t *testing.T) {
 			},
 		},
 	}
-
 	b3 := &api.PathBinding{
 		Verb: "GET",
 		PathTemplate: api.NewPathTemplate().
@@ -1169,7 +1205,6 @@ func TestPathBindingAnnotations(t *testing.T) {
 		PathFmt:     "/v2/foos",
 		QueryParams: []*api.Field{f_name, f_optional, f_child},
 	}
-
 	method := &api.Method{
 		Name:         "DoFoo",
 		ID:           ".test.Service.DoFoo",
@@ -1213,6 +1248,68 @@ func TestPathBindingAnnotations(t *testing.T) {
 	}
 }
 
+func TestPathBindingAnnotationsDetailedTracing(t *testing.T) {
+	f_name := &api.Field{
+		Name:     "name",
+		JSONName: "name",
+		ID:       ".test.Request.name",
+		Typez:    api.STRING_TYPE,
+	}
+	request := &api.Message{
+		Name:    "Request",
+		Package: "test",
+		ID:      ".test.Request",
+		Fields:  []*api.Field{f_name},
+	}
+	response := &api.Message{
+		Name:    "Response",
+		Package: "test",
+		ID:      ".test.Response",
+	}
+	binding := &api.PathBinding{
+		Verb: "POST",
+		PathTemplate: api.NewPathTemplate().
+			WithLiteral("v2").
+			WithVariable(api.NewPathVariable("name").
+				WithLiteral("projects").
+				WithMatch()).
+			WithVerb("create"),
+	}
+	method := &api.Method{
+		Name:         "DoFoo",
+		ID:           ".test.Service.DoFoo",
+		InputType:    request,
+		InputTypeID:  ".test.Request",
+		OutputTypeID: ".test.Response",
+		PathInfo: &api.PathInfo{
+			Bindings: []*api.PathBinding{binding},
+		},
+	}
+	service := &api.Service{
+		Name:    "FooService",
+		ID:      ".test.FooService",
+		Package: "test",
+		Methods: []*api.Method{method},
+	}
+	model := api.NewTestAPI(
+		[]*api.Message{request, response},
+		[]*api.Enum{},
+		[]*api.Service{service})
+	api.CrossReference(model)
+	codec, err := newCodec("protobuf", map[string]string{
+		"detailed-tracing-attributes": "true",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	annotateModel(model, codec)
+
+	got := binding.Codec.(*pathBindingAnnotation)
+	if !got.DetailedTracingAttributes {
+		t.Errorf("pathBindingAnnotation.DetailedTracingAttributes = %v, want %v", got.DetailedTracingAttributes, true)
+	}
+}
+
 func TestPathBindingAnnotationsStyle(t *testing.T) {
 	for _, test := range []struct {
 		FieldName     string
@@ -1525,6 +1622,44 @@ func TestGenerateSetterSamples(t *testing.T) {
 	}
 }
 
+func TestAnnotateModelWithDetailedTracing(t *testing.T) {
+	tests := []struct {
+		name    string
+		options map[string]string
+		want    bool
+	}{
+		{
+			name:    "DetailedTracingTrue",
+			options: map[string]string{"detailed-tracing-attributes": "true"},
+			want:    true,
+		},
+		{
+			name:    "DetailedTracingFalse",
+			options: map[string]string{"detailed-tracing-attributes": "false"},
+			want:    false,
+		},
+		{
+			name:    "DetailedTracingMissing",
+			options: map[string]string{},
+			want:    false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			model := api.NewTestAPI([]*api.Message{}, []*api.Enum{}, []*api.Service{})
+			codec, err := newCodec("protobuf", tt.options)
+			if err != nil {
+				t.Fatal(err)
+			}
+			got := annotateModel(model, codec)
+			if got.DetailedTracingAttributes != tt.want {
+				t.Errorf("annotateModel() DetailedTracingAttributes = %v, want %v", got.DetailedTracingAttributes, tt.want)
+			}
+		})
+	}
+}
+
 func TestSetterSampleAnnotations(t *testing.T) {
 	enum := &api.Enum{
 		Name:    "TestEnum",