Introduce model translation and encoding interfaces

[jrcamp]

This is a somewhat more limited version of #3044. It decouples
translation of models from encodings.

Models refers to the in-memory representation of a protcol like the zipkin v2
SpanModel. After translating from pdata to the model an encoding is used to
serialize the model to a particular byte representation (protobuf, JSON, etc.).
The reverse also applies in deserializing an encoding of bytes to a model then
translating the model to pdata.

The goal is to be able to have a generic way of translating and encoding to/from pdata from supported types (zipkin, Jaeger, etc.) without having to have explicit knowledge about all those types. For instance kafkareceiver/kafkaexporter can then be made to support any type that adheres to the interfaces without having to have knowledge about any of them specifically.

Open questions

* Currently encoding/decoding are separate interfaces which means you don't have to implement both. Model translation is currently a single interface which means you have to implement both. Should requiring two-way conversion be mandated by the interfaces like in translation or should you be able to implement only one-way conversions like the encode/decode interfaces are?

They were made separate interfaces.

[bogdandrutu]

map[encoding.Type]Encoder

[jrcamp]

I think it's possible but will require some helpers. Let's punt on it for now though as it doesn't impact the external API so can be easily tidied up later.

[bogdandrutu]

@jrcamp later we may want to add a "compressor" interface for things like https://github.com/open-telemetry/opentelemetry-collector/issues/3223. Or maybe we can use a standard library for that.

[bogdandrutu]

Top directory should be "model" instead of "protocols", see #3104 for the decision of the package.

[bogdandrutu]

Some feedback based on my quick PR to fix usage of internal protos in fileexporter:

• Because we accept/return byte[] instead of io.Reader/io.Writer need to do extra allocation and copy of the bytes
• I feel that "Serializer -> Marshaler" and "Deserializer -> Unmarshaler" makes more sense now :)

See #3238

[jrcamp]

Some feedback based on my quick PR to fix usage of internal protos in fileexporter:

• Because we accept/return byte[] instead of io.Reader/io.Writer need to do extra allocation and copy of the bytes

I looked into the io.{Reader,Writer} earlier and from what I could tell protobuf (binary representation) didn't appear to support them and dealt in []byte. And most of the existing serialization code seemed to return []byte which is why I went that route. (Not saying it's correct, just to explain how I got here).

I think both might have their place and maybe the answer is to support both. My concern about only supporting Reader/Writer would be internally the encoder is dealing in bytes, has to return bytes.NewReader(buf) then the user wants to deal in []byte so they ioutil.ReadAll(reader) which kind of defeats the whole purpose. :)

Perhaps both could be supported though?

// MetricsMarshaler encodes protocol-specific data model into bytes.
type MetricsMarshaler interface {
	MarshalMetrics(model interface{}) (io.Reader, error)
	MarshalMetricsBytes(model interface{}) ([]byte, error)
}

The protocol would implement one then the default implementation of the unimplemented one would call the implemented one and wrap/unwrap bytes as needed. But that way if you call MarshalMetricsBytes and internally it's dealing in bytes and you want bytes you don't have to double allocate. Maybe.

• I feel that "Serializer -> Marshaler" and "Deserializer -> Unmarshaler" makes more sense now :)

See #3238

[bogdandrutu]

I think this is good as a first step. Can you for the moment put it in the internal/model so we don't expose it publicly until we know the exact path we want?

[bogdandrutu]

internal/model/translator/translator.go:32:58: unexported-return: exported func NewErrIncompatibleType returns unexported type *translator.errIncompatibleType, which can be annoying to use (revive)
func NewErrIncompatibleType(expected, given interface{}) *errIncompatibleType {
                                                         ^

Just return error :)