Document strategy to support experimental methods on stable interfaces

[dashpole]

Forked from #5768, and related to open-telemetry/opentelemetry-specification#4257.

Problem Statement

We should document our policy for how we support for experimental things in the specification. It doesn't mean we will always accept such features, but should describe how it would work. This includes:

• Experimental behavior with no API artifacts (e.g. exemplar collection, service.instance.id auto-generation).
  • Today, we do this through /internal/x directories, and OTEL_GO_X_FOO environment variables.
• Experimental methods on SDK-only interfaces (e.g. span processor).
  • Today, we do this by adding the new interface in an internal directory, and doing type assertions on the internal interface as in Implement span processor's OnEnding #5756.
• Experimental methods on API (and SDK) interfaces.
  • This will be done using forks or long-lived branches on the repository.
• Experimental parameters (i.e. new option) for API functions.
• Experimental parameters (i.e. new option) for SDK functions.
• Experimental fields for API structs.
• Experimental fields for SDK structs.

This excludes:

• Experimental signals. It is assumed that these will be created as new, unstable modules while they are under development.

Proposed Solution

Decide and document how we are going to handle the above.

[dashpole]

Experimental methods on API (and SDK) interfaces.

The API could be E.g. otel/metric/experimentalmetric and otel/sdk/metric/experimentalmetric. The experimental API would embed the stable API, and also add the experimental method. The SDK would be harder to implement. It would need to include New() functions that implement the experimental API.

Maybe the experimental SDK would coordinate with the stable SDK through functions in an internal folder?

[dashpole]

@codeboten @bogdandrutu

[MrAlias]

Experimental methods on API (and SDK) interfaces.

The API could be E.g. otel/metric/experimentalmetric and otel/sdk/metric/experimentalmetric. The experimental API would embed the stable API, and also add the experimental method. The SDK would be harder to implement. It would need to include New() functions that implement the experimental API.

Maybe the experimental SDK would coordinate with the stable SDK through functions in an internal folder?

This approach means duplicate packages will need to be maintained. It also means users will need to rewrite their code switch between stable/experimental.

Why are branches and forks not a valid place for this type of code?

[pellared]

Why are branches and forks not a valid place for this type of code?

👍 While I hate "long-living branches" (because of maintainability burden), I do not think we have any other user-friendly alternatives.

I would not use build tags as all Go codebases depending on experimental features would have to be build with these build flags. This would be very user-unfriendly.

[dashpole]

Got it. I've added that to the description.

[pellared]

• Experimental parameters (i.e. new option) for API functions.
• Experimental parameters (i.e. new option) for SDK functions.
• Experimental fields for API structs.
• Experimental fields for SDK structs.

I think you can add this comment to these as well.

[mx-psi]

Why are branches and forks not a valid place for this type of code?

This is not a viable solution if you want to use opentelemetry-go types as part of your library's public API, is it? If that is the case, then

1. You are forced to use the fork indefinitely if you don't want to make a breaking change
2. (depending of the use case) You are forced to have some sort of 'bridge' between your fork and opentelemetry-go if you want to use a third library that does not use your fork

[mx-psi]

I would go as far as saying as a user of opentelemetry-go, I would rather have to deal with (properly namespaced) build tags than have to use a fork.

[tigrannajaryan]

• Experimental parameters (i.e. new option) for API functions.
• Experimental parameters (i.e. new option) for SDK functions.
• Experimental fields for API structs.
• Experimental fields for SDK structs.

I think you can add this comment to these as well.

@pellared are you referring to the approach used by gRPC where they label certain methods "Experimental", e.g. here? This is experimental methods within otherwise a stable package.

[mx-psi]

I think this comment may be relevant in this discussion: open-telemetry/opentelemetry-collector#4832 (comment) It summarizes ways in which grpc-go's policy has caused harm to the Go ecosystem

[pellared]

You are forced to use the fork indefinitely if you don't want to make a breaking change

@mx-psi, I think only a long-living branch with releases like v1.2.0-exp.1 would be a usable solution. Not a fork. This way applications would depend on experimental versions, would use the same import paths, and build tags would not be necessary.

[tigrannajaryan]

I would not use build tags as all Go codebases depending on experimental features would have to be build with these build flags. This would be very user-unfriendly.

@pellared can you expand on this? Why is this very user-unfriendly?

Also as an alternate to build flags, perhaps we could have runtime feature-flags to enable experimental APIs?

[mx-psi]

You are forced to use the fork indefinitely if you don't want to make a breaking change

@mx-psi, I think only a long-living branch with releases like v1.2.0-exp.1 would be a usable solution. Not a fork. This way applications would depend on experimental versions, would use the same import paths, and build tags would not be necessary.

That would definitely be an improvement. I am not sure how it would work with Go's MVS, but if it can work nicely with it, then that's definitely a solution