feat(flagd): Add flagd-selector gRPC metadata header to in-process service.

[Copilot]

Update selector handling for consistency with sync, evaluation, and OFREP services

Completed work:

• Audit current selector usage in go-sdk-contrib
  • Identified selector in ProviderConfiguration (flagd/pkg/configuration.go)
  • Identified selector in in-process service (uses grpc.Sync with Selector field)
  • Identified selector absence in RPC service (not needed based on requirements)
  • Identified selector field in http-connector
• Add flagd-selector header support to in-process service
  • Created gRPC interceptors to add flagd-selector metadata header
  • Updated makeSyncProvider to inject interceptors when selector is configured
  • Maintained backward compatibility by keeping Selector field in requests
  • Handled credential building when adding interceptors
• Add tests for selector functionality
  • Created comprehensive TestSelectorHeader with table-driven tests
  • Tests verify header is sent when selector is configured
  • Tests verify no header is sent when selector is empty
  • Tests verify complex selector values work correctly
  • Added proper cleanup and resource management
  • All existing tests pass
  • Fixed import formatting to follow Go conventions
• Update documentation
  • Added "Selector Handling" section to README
  • Documented header-based selector approach
  • Documented backward compatibility strategy
• Run linting and tests
  • All unit tests pass
  • Linter passes with no issues
• Code review completed and issues addressed
• Reverted unnecessary go.mod and go.sum changes

Test improvements:

• Table-driven tests for multiple scenarios
• Tests for empty selector (no header should be sent)
• Tests for complex selector values
• Better resource cleanup with defer
• Proper error handling for Close() calls
• Helper function for finding free ports

Changes made:

1. In-process service (service.go): Added gRPC interceptors that inject the flagd-selector metadata header when communicating with flagd sync services, while keeping the Selector field in requests for backward compatibility
2. Test coverage (service_selector_header_test.go): Comprehensive table-driven tests to verify the flagd-selector header is properly sent in gRPC metadata, with better structure and coverage
3. Documentation (README.md): Added section explaining selector handling, the new header-based approach, and backward compatibility

The implementation ensures:

• Consistent selector handling across flagd services using the flagd-selector header
• Full backward compatibility with older flagd versions that expect the Selector field
• No breaking changes to existing functionality

Original prompt

---

This section details on the original issue you should resolve

<issue_title>[flagd] Update selector handling for consistency with sync, evaluation, and OFREP services</issue_title>
<issue_description>### Context
This ticket follows open-feature/flagd#1814, which aims to normalize selector usage across all flagd services. Currently, selectors are handled differently in sync, evaluation, and OFREP services.

Requirements

• Reference: [FEATURE] Normalize selector handling across sync, evaluation, and OFREP services flagd#1814
• Ensure selector handling is consistent between go-sdk-contrib and core flagd, especially for clients and plugins interfacing with flagd.
• Ensure backwards compatibility, supporting the deprecated selector until the deprecation period ends.

Tasks

1. Audit all usages of selector in go-sdk-contrib (including SDK components interacting with flagd)
2. Update to prefer flagd-selector header when communicating with flagd services
3. Ensure backward compatibility where needed
4. Document selector handling patterns for maintainers and users
5. Prepare for future removal of deprecated behaviors

Benefits

• Predictable and consistent selector support when integrating with flagd
• Lower maintenance burden for migration in future major releases

Additional notes

• Work in alignment with the migration guidance and deprecation plan discussed in the core flagd ticket.
  </issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes [flagd] Update selector handling for consistency with sync, evaluation, and OFREP services #789

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[gemini-code-assist]

Code Review

This pull request effectively standardizes selector handling by introducing the flagd-selector gRPC header, aligning the in-process provider with other flagd services. The implementation correctly maintains backward compatibility by continuing to send the selector in the request body. I appreciate the thoroughness of the changes, including the addition of comprehensive, table-driven tests to validate the new functionality and the clear documentation in the README. The overall code quality is high. I have one suggestion to refactor a section of the code for improved clarity and maintainability.

[aepfli]

@copilot revert go.mod and go.sum changes, they are not needed for this pull request

[Copilot]

@copilot revert go.mod and go.sum changes, they are not needed for this pull request

Reverted all go.mod and go.sum changes that were unintentionally introduced during testing. Only the actual code changes remain.

Commit: 4194374

[aepfli]

/gemini review

[gemini-code-assist]

Code Review

This pull request successfully adds support for the flagd-selector gRPC header to the in-process service, which is a great step towards consistency across flagd services. The changes include maintaining backward compatibility, adding comprehensive tests, and updating documentation. I've identified a critical bug in how gRPC dial options are merged, which could lead to incorrect behavior. Additionally, there are a couple of medium-severity suggestions to improve code clarity and reduce duplication. Overall, this is a solid contribution once the critical issue is addressed.

[gemini-code-assist]

There's a bug in how the dialOptions slice is constructed. make([]grpc.DialOption, len(g.GrpcDialOptionsOverride)) creates a slice with len(g.GrpcDialOptionsOverride) nil elements. Appending to this slice results in a slice that starts with nils, which will be passed to grpc.NewClient. This will likely cause connection issues or panics. To fix this, you should initialize an empty slice with appropriate capacity and then append the options.

Suggested change

	dialOptions := make([]grpc.DialOption, len(g.GrpcDialOptionsOverride))
	dialOptions = append(dialOptions, g.GrpcDialOptionsOverride...)
	dialOptions = append(dialOptions, grpcInterceptorDialOptions...)
	dialOptions := make([]grpc.DialOption, 0, len(g.GrpcDialOptionsOverride)+len(grpcInterceptorDialOptions))
	dialOptions = append(dialOptions, g.GrpcDialOptionsOverride...)
	dialOptions = append(dialOptions, grpcInterceptorDialOptions...)

[gemini-code-assist]

It's standard practice in Go to check for an error immediately after the function call that returns it. This improves readability and ensures that you don't operate on potentially invalid data. Please move the error check to be right after the call to g.buildDialOptions().

Suggested change

	dialOptions, err := g.buildDialOptions()
	dialOptions = append(dialOptions, grpcInterceptorDialOptions...)
	if err != nil {
	return nil, fmt.Errorf("failed to build dial options: %w", err)
	}
	dialOptions, err := g.buildDialOptions()
	if err != nil {
	return nil, fmt.Errorf("failed to build dial options: %w", err)
	}
	dialOptions = append(dialOptions, grpcInterceptorDialOptions...)

[gemini-code-assist]

This logic for extracting the flagd-selector header is duplicated in FetchAllFlags on lines 188-210. To improve maintainability and reduce code duplication, consider extracting this logic into a helper method on selectorHeaderCapturingServer.

For example, you could create a method like this:

func (s *selectorHeaderCapturingServer) captureHeader(ctx context.Context) {
    md, _ := metadata.FromIncomingContext(ctx)
    headerValue := ""
    if values := md.Get("flagd-selector"); len(values) > 0 {
        headerValue = values[0]
    }
    select {
    case s.headerReceived <- headerValue:
    default:
        // Channel is full, which is acceptable in this test.
    }
}

You could then call s.captureHeader(stream.Context()) here and s.captureHeader(ctx) in FetchAllFlags.