rebase: update kubernetes and libraries to v1.22.0 version

Kubernetes v1.22 version has been released and this update
ceph csi dependencies to use the same version.

Signed-off-by: Humble Chirammal <hchiramm@redhat.com>

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig/envconfig.go

@@ -0,0 +1,196 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package otlpconfig
+
+import (
+	"crypto/tls"
+	"fmt"
+	"io/ioutil"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	"go.opentelemetry.io/otel/exporters/otlp"
+
+	"go.opentelemetry.io/otel"
+)
+
+func ApplyGRPCEnvConfigs(cfg *Config) {
+	e := EnvOptionsReader{
+		GetEnv:   os.Getenv,
+		ReadFile: ioutil.ReadFile,
+	}
+
+	e.ApplyGRPCEnvConfigs(cfg)
+}
+
+func ApplyHTTPEnvConfigs(cfg *Config) {
+	e := EnvOptionsReader{
+		GetEnv:   os.Getenv,
+		ReadFile: ioutil.ReadFile,
+	}
+
+	e.ApplyHTTPEnvConfigs(cfg)
+}
+
+type EnvOptionsReader struct {
+	GetEnv   func(string) string
+	ReadFile func(filename string) ([]byte, error)
+}
+
+func (e *EnvOptionsReader) ApplyHTTPEnvConfigs(cfg *Config) {
+	opts := e.GetOptionsFromEnv()
+	for _, opt := range opts {
+		opt.ApplyHTTPOption(cfg)
+	}
+}
+
+func (e *EnvOptionsReader) ApplyGRPCEnvConfigs(cfg *Config) {
+	opts := e.GetOptionsFromEnv()
+	for _, opt := range opts {
+		opt.ApplyGRPCOption(cfg)
+	}
+}
+
+func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
+	var opts []GenericOption
+
+	// Endpoint
+	if v, ok := e.getEnvValue("ENDPOINT"); ok {
+		opts = append(opts, WithEndpoint(v))
+	}
+	if v, ok := e.getEnvValue("TRACES_ENDPOINT"); ok {
+		opts = append(opts, WithTracesEndpoint(v))
+	}
+	if v, ok := e.getEnvValue("METRICS_ENDPOINT"); ok {
+		opts = append(opts, WithMetricsEndpoint(v))
+	}
+
+	// Certificate File
+	if path, ok := e.getEnvValue("CERTIFICATE"); ok {
+		if tls, err := e.readTLSConfig(path); err == nil {
+			opts = append(opts, WithTLSClientConfig(tls))
+		} else {
+			otel.Handle(fmt.Errorf("failed to configure otlp exporter certificate '%s': %w", path, err))
+		}
+	}
+	if path, ok := e.getEnvValue("TRACES_CERTIFICATE"); ok {
+		if tls, err := e.readTLSConfig(path); err == nil {
+			opts = append(opts, WithTracesTLSClientConfig(tls))
+		} else {
+			otel.Handle(fmt.Errorf("failed to configure otlp traces exporter certificate '%s': %w", path, err))
+		}
+	}
+	if path, ok := e.getEnvValue("METRICS_CERTIFICATE"); ok {
+		if tls, err := e.readTLSConfig(path); err == nil {
+			opts = append(opts, WithMetricsTLSClientConfig(tls))
+		} else {
+			otel.Handle(fmt.Errorf("failed to configure otlp metrics exporter certificate '%s': %w", path, err))
+		}
+	}
+
+	// Headers
+	if h, ok := e.getEnvValue("HEADERS"); ok {
+		opts = append(opts, WithHeaders(stringToHeader(h)))
+	}
+	if h, ok := e.getEnvValue("TRACES_HEADERS"); ok {
+		opts = append(opts, WithTracesHeaders(stringToHeader(h)))
+	}
+	if h, ok := e.getEnvValue("METRICS_HEADERS"); ok {
+		opts = append(opts, WithMetricsHeaders(stringToHeader(h)))
+	}
+
+	// Compression
+	if c, ok := e.getEnvValue("COMPRESSION"); ok {
+		opts = append(opts, WithCompression(stringToCompression(c)))
+	}
+	if c, ok := e.getEnvValue("TRACES_COMPRESSION"); ok {
+		opts = append(opts, WithTracesCompression(stringToCompression(c)))
+	}
+	if c, ok := e.getEnvValue("METRICS_COMPRESSION"); ok {
+		opts = append(opts, WithMetricsCompression(stringToCompression(c)))
+	}
+
+	// Timeout
+	if t, ok := e.getEnvValue("TIMEOUT"); ok {
+		if d, err := strconv.Atoi(t); err == nil {
+			opts = append(opts, WithTimeout(time.Duration(d)*time.Millisecond))
+		}
+	}
+	if t, ok := e.getEnvValue("TRACES_TIMEOUT"); ok {
+		if d, err := strconv.Atoi(t); err == nil {
+			opts = append(opts, WithTracesTimeout(time.Duration(d)*time.Millisecond))
+		}
+	}
+	if t, ok := e.getEnvValue("METRICS_TIMEOUT"); ok {
+		if d, err := strconv.Atoi(t); err == nil {
+			opts = append(opts, WithMetricsTimeout(time.Duration(d)*time.Millisecond))
+		}
+	}
+
+	return opts
+}
+
+// getEnvValue gets an OTLP environment variable value of the specified key using the GetEnv function.
+// This function already prepends the OTLP prefix to all key lookup.
+func (e *EnvOptionsReader) getEnvValue(key string) (string, bool) {
+	v := strings.TrimSpace(e.GetEnv(fmt.Sprintf("OTEL_EXPORTER_OTLP_%s", key)))
+	return v, v != ""
+}
+
+func (e *EnvOptionsReader) readTLSConfig(path string) (*tls.Config, error) {
+	b, err := e.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	return CreateTLSConfig(b)
+}
+
+func stringToCompression(value string) otlp.Compression {
+	switch value {
+	case "gzip":
+		return otlp.GzipCompression
+	}
+
+	return otlp.NoCompression
+}
+
+func stringToHeader(value string) map[string]string {
+	headersPairs := strings.Split(value, ",")
+	headers := make(map[string]string)
+
+	for _, header := range headersPairs {
+		nameValue := strings.SplitN(header, "=", 2)
+		if len(nameValue) < 2 {
+			continue
+		}
+		name, err := url.QueryUnescape(nameValue[0])
+		if err != nil {
+			continue
+		}
+		trimmedName := strings.TrimSpace(name)
+		value, err := url.QueryUnescape(nameValue[1])
+		if err != nil {
+			continue
+		}
+		trimmedValue := strings.TrimSpace(value)
+
+		headers[trimmedName] = trimmedValue
+	}
+
+	return headers
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig/options.go

@@ -0,0 +1,376 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig"
+
+import (
+	"crypto/tls"
+	"fmt"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/credentials"
+
+	"go.opentelemetry.io/otel/exporters/otlp"
+)
+
+const (
+	// DefaultMaxAttempts describes how many times the driver
+	// should retry the sending of the payload in case of a
+	// retryable error.
+	DefaultMaxAttempts int = 5
+	// DefaultTracesPath is a default URL path for endpoint that
+	// receives spans.
+	DefaultTracesPath string = "/v1/traces"
+	// DefaultMetricsPath is a default URL path for endpoint that
+	// receives metrics.
+	DefaultMetricsPath string = "/v1/metrics"
+	// DefaultBackoff is a default base backoff time used in the
+	// exponential backoff strategy.
+	DefaultBackoff time.Duration = 300 * time.Millisecond
+	// DefaultTimeout is a default max waiting time for the backend to process
+	// each span or metrics batch.
+	DefaultTimeout time.Duration = 10 * time.Second
+	// DefaultServiceConfig is the gRPC service config used if none is
+	// provided by the user.
+	DefaultServiceConfig = `{
+	"methodConfig":[{
+		"name":[
+			{ "service":"opentelemetry.proto.collector.metrics.v1.MetricsService" },
+			{ "service":"opentelemetry.proto.collector.trace.v1.TraceService" }
+		],
+		"retryPolicy":{
+			"MaxAttempts":5,
+			"InitialBackoff":"0.3s",
+			"MaxBackoff":"5s",
+			"BackoffMultiplier":2,
+			"RetryableStatusCodes":[
+				"CANCELLED",
+				"DEADLINE_EXCEEDED",
+				"RESOURCE_EXHAUSTED",
+				"ABORTED",
+				"OUT_OF_RANGE",
+				"UNAVAILABLE",
+				"DATA_LOSS"
+			]
+		}
+	}]
+}`
+)
+
+type (
+	SignalConfig struct {
+		Endpoint    string
+		Insecure    bool
+		TLSCfg      *tls.Config
+		Headers     map[string]string
+		Compression otlp.Compression
+		Timeout     time.Duration
+		URLPath     string
+
+		// gRPC configurations
+		GRPCCredentials credentials.TransportCredentials
+	}
+
+	Config struct {
+		// Signal specific configurations
+		Metrics SignalConfig
+		Traces  SignalConfig
+
+		// General configurations
+		MaxAttempts int
+		Backoff     time.Duration
+
+		// HTTP configuration
+		Marshaler otlp.Marshaler
+
+		// gRPC configurations
+		ReconnectionPeriod time.Duration
+		ServiceConfig      string
+		DialOptions        []grpc.DialOption
+	}
+)
+
+func NewDefaultConfig() Config {
+	c := Config{
+		Traces: SignalConfig{
+			Endpoint:    fmt.Sprintf("%s:%d", otlp.DefaultCollectorHost, otlp.DefaultCollectorPort),
+			URLPath:     DefaultTracesPath,
+			Compression: otlp.NoCompression,
+			Timeout:     DefaultTimeout,
+		},
+		Metrics: SignalConfig{
+			Endpoint:    fmt.Sprintf("%s:%d", otlp.DefaultCollectorHost, otlp.DefaultCollectorPort),
+			URLPath:     DefaultMetricsPath,
+			Compression: otlp.NoCompression,
+			Timeout:     DefaultTimeout,
+		},
+		MaxAttempts:   DefaultMaxAttempts,
+		Backoff:       DefaultBackoff,
+		ServiceConfig: DefaultServiceConfig,
+	}
+
+	return c
+}
+
+type (
+	// GenericOption applies an option to the HTTP or gRPC driver.
+	GenericOption interface {
+		ApplyHTTPOption(*Config)
+		ApplyGRPCOption(*Config)
+
+		// A private method to prevent users implementing the
+		// interface and so future additions to it will not
+		// violate compatibility.
+		private()
+	}
+
+	// HTTPOption applies an option to the HTTP driver.
+	HTTPOption interface {
+		ApplyHTTPOption(*Config)
+
+		// A private method to prevent users implementing the
+		// interface and so future additions to it will not
+		// violate compatibility.
+		private()
+	}
+
+	// GRPCOption applies an option to the gRPC driver.
+	GRPCOption interface {
+		ApplyGRPCOption(*Config)
+
+		// A private method to prevent users implementing the
+		// interface and so future additions to it will not
+		// violate compatibility.
+		private()
+	}
+)
+
+// genericOption is an option that applies the same logic
+// for both gRPC and HTTP.
+type genericOption struct {
+	fn func(*Config)
+}
+
+func (g *genericOption) ApplyGRPCOption(cfg *Config) {
+	g.fn(cfg)
+}
+
+func (g *genericOption) ApplyHTTPOption(cfg *Config) {
+	g.fn(cfg)
+}
+
+func (genericOption) private() {}
+
+func newGenericOption(fn func(cfg *Config)) GenericOption {
+	return &genericOption{fn: fn}
+}
+
+// splitOption is an option that applies different logics
+// for gRPC and HTTP.
+type splitOption struct {
+	httpFn func(*Config)
+	grpcFn func(*Config)
+}
+
+func (g *splitOption) ApplyGRPCOption(cfg *Config) {
+	g.grpcFn(cfg)
+}
+
+func (g *splitOption) ApplyHTTPOption(cfg *Config) {
+	g.httpFn(cfg)
+}
+
+func (splitOption) private() {}
+
+func newSplitOption(httpFn func(cfg *Config), grpcFn func(cfg *Config)) GenericOption {
+	return &splitOption{httpFn: httpFn, grpcFn: grpcFn}
+}
+
+// httpOption is an option that is only applied to the HTTP driver.
+type httpOption struct {
+	fn func(*Config)
+}
+
+func (h *httpOption) ApplyHTTPOption(cfg *Config) {
+	h.fn(cfg)
+}
+
+func (httpOption) private() {}
+
+func NewHTTPOption(fn func(cfg *Config)) HTTPOption {
+	return &httpOption{fn: fn}
+}
+
+// grpcOption is an option that is only applied to the gRPC driver.
+type grpcOption struct {
+	fn func(*Config)
+}
+
+func (h *grpcOption) ApplyGRPCOption(cfg *Config) {
+	h.fn(cfg)
+}
+
+func (grpcOption) private() {}
+
+func NewGRPCOption(fn func(cfg *Config)) GRPCOption {
+	return &grpcOption{fn: fn}
+}
+
+// Generic Options
+
+func WithEndpoint(endpoint string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Endpoint = endpoint
+		cfg.Metrics.Endpoint = endpoint
+	})
+}
+
+func WithTracesEndpoint(endpoint string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Endpoint = endpoint
+	})
+}
+
+func WithMetricsEndpoint(endpoint string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Endpoint = endpoint
+	})
+}
+
+func WithCompression(compression otlp.Compression) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Compression = compression
+		cfg.Metrics.Compression = compression
+	})
+}
+
+func WithTracesCompression(compression otlp.Compression) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Compression = compression
+	})
+}
+
+func WithMetricsCompression(compression otlp.Compression) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Compression = compression
+	})
+}
+
+func WithTracesURLPath(urlPath string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.URLPath = urlPath
+	})
+}
+
+func WithMetricsURLPath(urlPath string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.URLPath = urlPath
+	})
+}
+
+func WithMaxAttempts(maxAttempts int) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.MaxAttempts = maxAttempts
+	})
+}
+
+func WithBackoff(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Backoff = duration
+	})
+}
+
+func WithTLSClientConfig(tlsCfg *tls.Config) GenericOption {
+	return newSplitOption(func(cfg *Config) {
+		cfg.Traces.TLSCfg = tlsCfg.Clone()
+		cfg.Metrics.TLSCfg = tlsCfg.Clone()
+	}, func(cfg *Config) {
+		cfg.Traces.GRPCCredentials = credentials.NewTLS(tlsCfg)
+		cfg.Metrics.GRPCCredentials = credentials.NewTLS(tlsCfg)
+	})
+}
+
+func WithTracesTLSClientConfig(tlsCfg *tls.Config) GenericOption {
+	return newSplitOption(func(cfg *Config) {
+		cfg.Traces.TLSCfg = tlsCfg.Clone()
+	}, func(cfg *Config) {
+		cfg.Traces.GRPCCredentials = credentials.NewTLS(tlsCfg)
+	})
+}
+
+func WithMetricsTLSClientConfig(tlsCfg *tls.Config) GenericOption {
+	return newSplitOption(func(cfg *Config) {
+		cfg.Metrics.TLSCfg = tlsCfg.Clone()
+	}, func(cfg *Config) {
+		cfg.Metrics.GRPCCredentials = credentials.NewTLS(tlsCfg)
+	})
+}
+
+func WithInsecure() GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Insecure = true
+		cfg.Metrics.Insecure = true
+	})
+}
+
+func WithInsecureTraces() GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Insecure = true
+	})
+}
+
+func WithInsecureMetrics() GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Insecure = true
+	})
+}
+
+func WithHeaders(headers map[string]string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Headers = headers
+		cfg.Metrics.Headers = headers
+	})
+}
+
+func WithTracesHeaders(headers map[string]string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Headers = headers
+	})
+}
+
+func WithMetricsHeaders(headers map[string]string) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Headers = headers
+	})
+}
+
+func WithTimeout(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Timeout = duration
+		cfg.Metrics.Timeout = duration
+	})
+}
+
+func WithTracesTimeout(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Traces.Timeout = duration
+	})
+}
+
+func WithMetricsTimeout(duration time.Duration) GenericOption {
+	return newGenericOption(func(cfg *Config) {
+		cfg.Metrics.Timeout = duration
+	})
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/otlpconfig/tls.go

@@ -0,0 +1,69 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package otlpconfig
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"errors"
+	"io/ioutil"
+)
+
+const (
+	WeakCertificate = `
+-----BEGIN CERTIFICATE-----
+MIIBhzCCASygAwIBAgIRANHpHgAWeTnLZpTSxCKs0ggwCgYIKoZIzj0EAwIwEjEQ
+MA4GA1UEChMHb3RlbC1nbzAeFw0yMTA0MDExMzU5MDNaFw0yMTA0MDExNDU5MDNa
+MBIxEDAOBgNVBAoTB290ZWwtZ28wWTATBgcqhkjOPQIBBggqhkjOPQMBBwNCAAS9
+nWSkmPCxShxnp43F+PrOtbGV7sNfkbQ/kxzi9Ego0ZJdiXxkmv/C05QFddCW7Y0Z
+sJCLHGogQsYnWJBXUZOVo2MwYTAOBgNVHQ8BAf8EBAMCB4AwEwYDVR0lBAwwCgYI
+KwYBBQUHAwEwDAYDVR0TAQH/BAIwADAsBgNVHREEJTAjgglsb2NhbGhvc3SHEAAA
+AAAAAAAAAAAAAAAAAAGHBH8AAAEwCgYIKoZIzj0EAwIDSQAwRgIhANwZVVKvfvQ/
+1HXsTvgH+xTQswOwSSKYJ1cVHQhqK7ZbAiEAus8NxpTRnp5DiTMuyVmhVNPB+bVH
+Lhnm4N/QDk5rek0=
+-----END CERTIFICATE-----
+`
+	WeakPrivateKey = `
+-----BEGIN PRIVATE KEY-----
+MIGHAgEAMBMGByqGSM49AgEGCCqGSM49AwEHBG0wawIBAQQgN8HEXiXhvByrJ1zK
+SFT6Y2l2KqDWwWzKf+t4CyWrNKehRANCAAS9nWSkmPCxShxnp43F+PrOtbGV7sNf
+kbQ/kxzi9Ego0ZJdiXxkmv/C05QFddCW7Y0ZsJCLHGogQsYnWJBXUZOV
+-----END PRIVATE KEY-----
+`
+)
+
+// ReadTLSConfigFromFile reads a PEM certificate file and creates
+// a tls.Config that will use this certifate to verify a server certificate.
+func ReadTLSConfigFromFile(path string) (*tls.Config, error) {
+	b, err := ioutil.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	return CreateTLSConfig(b)
+}
+
+// CreateTLSConfig creates a tls.Config from a raw certificate bytes
+// to verify a server certificate.
+func CreateTLSConfig(certBytes []byte) (*tls.Config, error) {
+	cp := x509.NewCertPool()
+	if ok := cp.AppendCertsFromPEM(certBytes); !ok {
+		return nil, errors.New("failed to append certificate to the cert pool")
+	}
+
+	return &tls.Config{
+		RootCAs: cp,
+	}, nil
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/transform/attribute.go

@@ -0,0 +1,141 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transform
+
+import (
+	"reflect"
+
+	"go.opentelemetry.io/otel/attribute"
+	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
+
+	"go.opentelemetry.io/otel/sdk/resource"
+)
+
+// Attributes transforms a slice of KeyValues into a slice of OTLP attribute key-values.
+func Attributes(attrs []attribute.KeyValue) []*commonpb.KeyValue {
+	if len(attrs) == 0 {
+		return nil
+	}
+
+	out := make([]*commonpb.KeyValue, 0, len(attrs))
+	for _, kv := range attrs {
+		out = append(out, toAttribute(kv))
+	}
+	return out
+}
+
+// ResourceAttributes transforms a Resource into a slice of OTLP attribute key-values.
+func ResourceAttributes(resource *resource.Resource) []*commonpb.KeyValue {
+	if resource.Len() == 0 {
+		return nil
+	}
+
+	out := make([]*commonpb.KeyValue, 0, resource.Len())
+	for iter := resource.Iter(); iter.Next(); {
+		out = append(out, toAttribute(iter.Attribute()))
+	}
+
+	return out
+}
+
+func toAttribute(v attribute.KeyValue) *commonpb.KeyValue {
+	result := &commonpb.KeyValue{
+		Key:   string(v.Key),
+		Value: new(commonpb.AnyValue),
+	}
+	switch v.Value.Type() {
+	case attribute.BOOL:
+		result.Value.Value = &commonpb.AnyValue_BoolValue{
+			BoolValue: v.Value.AsBool(),
+		}
+	case attribute.INT64:
+		result.Value.Value = &commonpb.AnyValue_IntValue{
+			IntValue: v.Value.AsInt64(),
+		}
+	case attribute.FLOAT64:
+		result.Value.Value = &commonpb.AnyValue_DoubleValue{
+			DoubleValue: v.Value.AsFloat64(),
+		}
+	case attribute.STRING:
+		result.Value.Value = &commonpb.AnyValue_StringValue{
+			StringValue: v.Value.AsString(),
+		}
+	case attribute.ARRAY:
+		result.Value.Value = &commonpb.AnyValue_ArrayValue{
+			ArrayValue: &commonpb.ArrayValue{
+				Values: arrayValues(v),
+			},
+		}
+	default:
+		result.Value.Value = &commonpb.AnyValue_StringValue{
+			StringValue: "INVALID",
+		}
+	}
+	return result
+}
+
+func arrayValues(kv attribute.KeyValue) []*commonpb.AnyValue {
+	a := kv.Value.AsArray()
+	aType := reflect.TypeOf(a)
+	var valueFunc func(reflect.Value) *commonpb.AnyValue
+	switch aType.Elem().Kind() {
+	case reflect.Bool:
+		valueFunc = func(v reflect.Value) *commonpb.AnyValue {
+			return &commonpb.AnyValue{
+				Value: &commonpb.AnyValue_BoolValue{
+					BoolValue: v.Bool(),
+				},
+			}
+		}
+	case reflect.Int, reflect.Int64:
+		valueFunc = func(v reflect.Value) *commonpb.AnyValue {
+			return &commonpb.AnyValue{
+				Value: &commonpb.AnyValue_IntValue{
+					IntValue: v.Int(),
+				},
+			}
+		}
+	case reflect.Uintptr:
+		valueFunc = func(v reflect.Value) *commonpb.AnyValue {
+			return &commonpb.AnyValue{
+				Value: &commonpb.AnyValue_IntValue{
+					IntValue: int64(v.Uint()),
+				},
+			}
+		}
+	case reflect.Float64:
+		valueFunc = func(v reflect.Value) *commonpb.AnyValue {
+			return &commonpb.AnyValue{
+				Value: &commonpb.AnyValue_DoubleValue{
+					DoubleValue: v.Float(),
+				},
+			}
+		}
+	case reflect.String:
+		valueFunc = func(v reflect.Value) *commonpb.AnyValue {
+			return &commonpb.AnyValue{
+				Value: &commonpb.AnyValue_StringValue{
+					StringValue: v.String(),
+				},
+			}
+		}
+	}
+
+	results := make([]*commonpb.AnyValue, aType.Len())
+	for i, aValue := 0, reflect.ValueOf(a); i < aValue.Len(); i++ {
+		results[i] = valueFunc(aValue.Index(i))
+	}
+	return results
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/transform/instrumentation.go

@@ -0,0 +1,31 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transform
+
+import (
+	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
+
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+)
+
+func instrumentationLibrary(il instrumentation.Library) *commonpb.InstrumentationLibrary {
+	if il == (instrumentation.Library{}) {
+		return nil
+	}
+	return &commonpb.InstrumentationLibrary{
+		Name:    il.Name,
+		Version: il.Version,
+	}
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/transform/metric.go

@@ -0,0 +1,631 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package transform provides translations for opentelemetry-go concepts and
+// structures to otlp structures.
+package transform
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+
+	"go.opentelemetry.io/otel/attribute"
+	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
+	metricpb "go.opentelemetry.io/proto/otlp/metrics/v1"
+	resourcepb "go.opentelemetry.io/proto/otlp/resource/v1"
+
+	"go.opentelemetry.io/otel/metric/number"
+	export "go.opentelemetry.io/otel/sdk/export/metric"
+	"go.opentelemetry.io/otel/sdk/export/metric/aggregation"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+	"go.opentelemetry.io/otel/sdk/resource"
+)
+
+var (
+	// ErrUnimplementedAgg is returned when a transformation of an unimplemented
+	// aggregator is attempted.
+	ErrUnimplementedAgg = errors.New("unimplemented aggregator")
+
+	// ErrIncompatibleAgg is returned when
+	// aggregation.Kind implies an interface conversion that has
+	// failed
+	ErrIncompatibleAgg = errors.New("incompatible aggregation type")
+
+	// ErrUnknownValueType is returned when a transformation of an unknown value
+	// is attempted.
+	ErrUnknownValueType = errors.New("invalid value type")
+
+	// ErrContextCanceled is returned when a context cancellation halts a
+	// transformation.
+	ErrContextCanceled = errors.New("context canceled")
+
+	// ErrTransforming is returned when an unexected error is encoutered transforming.
+	ErrTransforming = errors.New("transforming failed")
+)
+
+// result is the product of transforming Records into OTLP Metrics.
+type result struct {
+	Resource               *resource.Resource
+	InstrumentationLibrary instrumentation.Library
+	Metric                 *metricpb.Metric
+	Err                    error
+}
+
+// toNanos returns the number of nanoseconds since the UNIX epoch.
+func toNanos(t time.Time) uint64 {
+	if t.IsZero() {
+		return 0
+	}
+	return uint64(t.UnixNano())
+}
+
+// CheckpointSet transforms all records contained in a checkpoint into
+// batched OTLP ResourceMetrics.
+func CheckpointSet(ctx context.Context, exportSelector export.ExportKindSelector, cps export.CheckpointSet, numWorkers uint) ([]*metricpb.ResourceMetrics, error) {
+	records, errc := source(ctx, exportSelector, cps)
+
+	// Start a fixed number of goroutines to transform records.
+	transformed := make(chan result)
+	var wg sync.WaitGroup
+	wg.Add(int(numWorkers))
+	for i := uint(0); i < numWorkers; i++ {
+		go func() {
+			defer wg.Done()
+			transformer(ctx, exportSelector, records, transformed)
+		}()
+	}
+	go func() {
+		wg.Wait()
+		close(transformed)
+	}()
+
+	// Synchronously collect the transformed records and transmit.
+	rms, err := sink(ctx, transformed)
+	if err != nil {
+		return nil, err
+	}
+
+	// source is complete, check for any errors.
+	if err := <-errc; err != nil {
+		return nil, err
+	}
+	return rms, nil
+}
+
+// source starts a goroutine that sends each one of the Records yielded by
+// the CheckpointSet on the returned chan. Any error encoutered will be sent
+// on the returned error chan after seeding is complete.
+func source(ctx context.Context, exportSelector export.ExportKindSelector, cps export.CheckpointSet) (<-chan export.Record, <-chan error) {
+	errc := make(chan error, 1)
+	out := make(chan export.Record)
+	// Seed records into process.
+	go func() {
+		defer close(out)
+		// No select is needed since errc is buffered.
+		errc <- cps.ForEach(exportSelector, func(r export.Record) error {
+			select {
+			case <-ctx.Done():
+				return ErrContextCanceled
+			case out <- r:
+			}
+			return nil
+		})
+	}()
+	return out, errc
+}
+
+// transformer transforms records read from the passed in chan into
+// OTLP Metrics which are sent on the out chan.
+func transformer(ctx context.Context, exportSelector export.ExportKindSelector, in <-chan export.Record, out chan<- result) {
+	for r := range in {
+		m, err := Record(exportSelector, r)
+		// Propagate errors, but do not send empty results.
+		if err == nil && m == nil {
+			continue
+		}
+		res := result{
+			Resource: r.Resource(),
+			InstrumentationLibrary: instrumentation.Library{
+				Name:    r.Descriptor().InstrumentationName(),
+				Version: r.Descriptor().InstrumentationVersion(),
+			},
+			Metric: m,
+			Err:    err,
+		}
+		select {
+		case <-ctx.Done():
+			return
+		case out <- res:
+		}
+	}
+}
+
+// sink collects transformed Records and batches them.
+//
+// Any errors encoutered transforming input will be reported with an
+// ErrTransforming as well as the completed ResourceMetrics. It is up to the
+// caller to handle any incorrect data in these ResourceMetrics.
+func sink(ctx context.Context, in <-chan result) ([]*metricpb.ResourceMetrics, error) {
+	var errStrings []string
+
+	type resourceBatch struct {
+		Resource *resourcepb.Resource
+		// Group by instrumentation library name and then the MetricDescriptor.
+		InstrumentationLibraryBatches map[instrumentation.Library]map[string]*metricpb.Metric
+	}
+
+	// group by unique Resource string.
+	grouped := make(map[attribute.Distinct]resourceBatch)
+	for res := range in {
+		if res.Err != nil {
+			errStrings = append(errStrings, res.Err.Error())
+			continue
+		}
+
+		rID := res.Resource.Equivalent()
+		rb, ok := grouped[rID]
+		if !ok {
+			rb = resourceBatch{
+				Resource:                      Resource(res.Resource),
+				InstrumentationLibraryBatches: make(map[instrumentation.Library]map[string]*metricpb.Metric),
+			}
+			grouped[rID] = rb
+		}
+
+		mb, ok := rb.InstrumentationLibraryBatches[res.InstrumentationLibrary]
+		if !ok {
+			mb = make(map[string]*metricpb.Metric)
+			rb.InstrumentationLibraryBatches[res.InstrumentationLibrary] = mb
+		}
+
+		mID := res.Metric.GetName()
+		m, ok := mb[mID]
+		if !ok {
+			mb[mID] = res.Metric
+			continue
+		}
+		switch res.Metric.Data.(type) {
+		case *metricpb.Metric_IntGauge:
+			m.GetIntGauge().DataPoints = append(m.GetIntGauge().DataPoints, res.Metric.GetIntGauge().DataPoints...)
+		case *metricpb.Metric_IntHistogram:
+			m.GetIntHistogram().DataPoints = append(m.GetIntHistogram().DataPoints, res.Metric.GetIntHistogram().DataPoints...)
+		case *metricpb.Metric_IntSum:
+			m.GetIntSum().DataPoints = append(m.GetIntSum().DataPoints, res.Metric.GetIntSum().DataPoints...)
+		case *metricpb.Metric_DoubleGauge:
+			m.GetDoubleGauge().DataPoints = append(m.GetDoubleGauge().DataPoints, res.Metric.GetDoubleGauge().DataPoints...)
+		case *metricpb.Metric_DoubleHistogram:
+			m.GetDoubleHistogram().DataPoints = append(m.GetDoubleHistogram().DataPoints, res.Metric.GetDoubleHistogram().DataPoints...)
+		case *metricpb.Metric_DoubleSum:
+			m.GetDoubleSum().DataPoints = append(m.GetDoubleSum().DataPoints, res.Metric.GetDoubleSum().DataPoints...)
+		default:
+		}
+	}
+
+	if len(grouped) == 0 {
+		return nil, nil
+	}
+
+	var rms []*metricpb.ResourceMetrics
+	for _, rb := range grouped {
+		rm := &metricpb.ResourceMetrics{Resource: rb.Resource}
+		for il, mb := range rb.InstrumentationLibraryBatches {
+			ilm := &metricpb.InstrumentationLibraryMetrics{
+				Metrics: make([]*metricpb.Metric, 0, len(mb)),
+			}
+			if il != (instrumentation.Library{}) {
+				ilm.InstrumentationLibrary = &commonpb.InstrumentationLibrary{
+					Name:    il.Name,
+					Version: il.Version,
+				}
+			}
+			for _, m := range mb {
+				ilm.Metrics = append(ilm.Metrics, m)
+			}
+			rm.InstrumentationLibraryMetrics = append(rm.InstrumentationLibraryMetrics, ilm)
+		}
+		rms = append(rms, rm)
+	}
+
+	// Report any transform errors.
+	if len(errStrings) > 0 {
+		return rms, fmt.Errorf("%w:\n -%s", ErrTransforming, strings.Join(errStrings, "\n -"))
+	}
+	return rms, nil
+}
+
+// Record transforms a Record into an OTLP Metric. An ErrIncompatibleAgg
+// error is returned if the Record Aggregator is not supported.
+func Record(exportSelector export.ExportKindSelector, r export.Record) (*metricpb.Metric, error) {
+	agg := r.Aggregation()
+	switch agg.Kind() {
+	case aggregation.MinMaxSumCountKind:
+		mmsc, ok := agg.(aggregation.MinMaxSumCount)
+		if !ok {
+			return nil, fmt.Errorf("%w: %T", ErrIncompatibleAgg, agg)
+		}
+		return minMaxSumCount(r, mmsc)
+
+	case aggregation.HistogramKind:
+		h, ok := agg.(aggregation.Histogram)
+		if !ok {
+			return nil, fmt.Errorf("%w: %T", ErrIncompatibleAgg, agg)
+		}
+		return histogramPoint(r, exportSelector.ExportKindFor(r.Descriptor(), aggregation.HistogramKind), h)
+
+	case aggregation.SumKind:
+		s, ok := agg.(aggregation.Sum)
+		if !ok {
+			return nil, fmt.Errorf("%w: %T", ErrIncompatibleAgg, agg)
+		}
+		sum, err := s.Sum()
+		if err != nil {
+			return nil, err
+		}
+		return sumPoint(r, sum, r.StartTime(), r.EndTime(), exportSelector.ExportKindFor(r.Descriptor(), aggregation.SumKind), r.Descriptor().InstrumentKind().Monotonic())
+
+	case aggregation.LastValueKind:
+		lv, ok := agg.(aggregation.LastValue)
+		if !ok {
+			return nil, fmt.Errorf("%w: %T", ErrIncompatibleAgg, agg)
+		}
+		value, tm, err := lv.LastValue()
+		if err != nil {
+			return nil, err
+		}
+		return gaugePoint(r, value, time.Time{}, tm)
+
+	case aggregation.ExactKind:
+		e, ok := agg.(aggregation.Points)
+		if !ok {
+			return nil, fmt.Errorf("%w: %T", ErrIncompatibleAgg, agg)
+		}
+		pts, err := e.Points()
+		if err != nil {
+			return nil, err
+		}
+
+		return gaugeArray(r, pts)
+
+	default:
+		return nil, fmt.Errorf("%w: %T", ErrUnimplementedAgg, agg)
+	}
+}
+
+func gaugeArray(record export.Record, points []aggregation.Point) (*metricpb.Metric, error) {
+	desc := record.Descriptor()
+	labels := record.Labels()
+	m := &metricpb.Metric{
+		Name:        desc.Name(),
+		Description: desc.Description(),
+		Unit:        string(desc.Unit()),
+	}
+
+	pbLabels := stringKeyValues(labels.Iter())
+
+	switch nk := desc.NumberKind(); nk {
+	case number.Int64Kind:
+		var pts []*metricpb.IntDataPoint
+		for _, s := range points {
+			pts = append(pts, &metricpb.IntDataPoint{
+				Labels:            pbLabels,
+				StartTimeUnixNano: toNanos(record.StartTime()),
+				TimeUnixNano:      toNanos(record.EndTime()),
+				Value:             s.Number.CoerceToInt64(nk),
+			})
+		}
+		m.Data = &metricpb.Metric_IntGauge{
+			IntGauge: &metricpb.IntGauge{
+				DataPoints: pts,
+			},
+		}
+
+	case number.Float64Kind:
+		var pts []*metricpb.DoubleDataPoint
+		for _, s := range points {
+			pts = append(pts, &metricpb.DoubleDataPoint{
+				Labels:            pbLabels,
+				StartTimeUnixNano: toNanos(record.StartTime()),
+				TimeUnixNano:      toNanos(record.EndTime()),
+				Value:             s.Number.CoerceToFloat64(nk),
+			})
+		}
+		m.Data = &metricpb.Metric_DoubleGauge{
+			DoubleGauge: &metricpb.DoubleGauge{
+				DataPoints: pts,
+			},
+		}
+
+	default:
+		return nil, fmt.Errorf("%w: %v", ErrUnknownValueType, nk)
+	}
+
+	return m, nil
+}
+
+func gaugePoint(record export.Record, num number.Number, start, end time.Time) (*metricpb.Metric, error) {
+	desc := record.Descriptor()
+	labels := record.Labels()
+
+	m := &metricpb.Metric{
+		Name:        desc.Name(),
+		Description: desc.Description(),
+		Unit:        string(desc.Unit()),
+	}
+
+	switch n := desc.NumberKind(); n {
+	case number.Int64Kind:
+		m.Data = &metricpb.Metric_IntGauge{
+			IntGauge: &metricpb.IntGauge{
+				DataPoints: []*metricpb.IntDataPoint{
+					{
+						Value:             num.CoerceToInt64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(start),
+						TimeUnixNano:      toNanos(end),
+					},
+				},
+			},
+		}
+	case number.Float64Kind:
+		m.Data = &metricpb.Metric_DoubleGauge{
+			DoubleGauge: &metricpb.DoubleGauge{
+				DataPoints: []*metricpb.DoubleDataPoint{
+					{
+						Value:             num.CoerceToFloat64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(start),
+						TimeUnixNano:      toNanos(end),
+					},
+				},
+			},
+		}
+	default:
+		return nil, fmt.Errorf("%w: %v", ErrUnknownValueType, n)
+	}
+
+	return m, nil
+}
+
+func exportKindToTemporality(ek export.ExportKind) metricpb.AggregationTemporality {
+	switch ek {
+	case export.DeltaExportKind:
+		return metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_DELTA
+	case export.CumulativeExportKind:
+		return metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_CUMULATIVE
+	}
+	return metricpb.AggregationTemporality_AGGREGATION_TEMPORALITY_UNSPECIFIED
+}
+
+func sumPoint(record export.Record, num number.Number, start, end time.Time, ek export.ExportKind, monotonic bool) (*metricpb.Metric, error) {
+	desc := record.Descriptor()
+	labels := record.Labels()
+
+	m := &metricpb.Metric{
+		Name:        desc.Name(),
+		Description: desc.Description(),
+		Unit:        string(desc.Unit()),
+	}
+
+	switch n := desc.NumberKind(); n {
+	case number.Int64Kind:
+		m.Data = &metricpb.Metric_IntSum{
+			IntSum: &metricpb.IntSum{
+				IsMonotonic:            monotonic,
+				AggregationTemporality: exportKindToTemporality(ek),
+				DataPoints: []*metricpb.IntDataPoint{
+					{
+						Value:             num.CoerceToInt64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(start),
+						TimeUnixNano:      toNanos(end),
+					},
+				},
+			},
+		}
+	case number.Float64Kind:
+		m.Data = &metricpb.Metric_DoubleSum{
+			DoubleSum: &metricpb.DoubleSum{
+				IsMonotonic:            monotonic,
+				AggregationTemporality: exportKindToTemporality(ek),
+				DataPoints: []*metricpb.DoubleDataPoint{
+					{
+						Value:             num.CoerceToFloat64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(start),
+						TimeUnixNano:      toNanos(end),
+					},
+				},
+			},
+		}
+	default:
+		return nil, fmt.Errorf("%w: %v", ErrUnknownValueType, n)
+	}
+
+	return m, nil
+}
+
+// minMaxSumCountValue returns the values of the MinMaxSumCount Aggregator
+// as discrete values.
+func minMaxSumCountValues(a aggregation.MinMaxSumCount) (min, max, sum number.Number, count uint64, err error) {
+	if min, err = a.Min(); err != nil {
+		return
+	}
+	if max, err = a.Max(); err != nil {
+		return
+	}
+	if sum, err = a.Sum(); err != nil {
+		return
+	}
+	if count, err = a.Count(); err != nil {
+		return
+	}
+	return
+}
+
+// minMaxSumCount transforms a MinMaxSumCount Aggregator into an OTLP Metric.
+func minMaxSumCount(record export.Record, a aggregation.MinMaxSumCount) (*metricpb.Metric, error) {
+	desc := record.Descriptor()
+	labels := record.Labels()
+	min, max, sum, count, err := minMaxSumCountValues(a)
+	if err != nil {
+		return nil, err
+	}
+
+	m := &metricpb.Metric{
+		Name:        desc.Name(),
+		Description: desc.Description(),
+		Unit:        string(desc.Unit()),
+	}
+
+	buckets := []uint64{min.AsRaw(), max.AsRaw()}
+	bounds := []float64{0.0, 100.0}
+
+	switch n := desc.NumberKind(); n {
+	case number.Int64Kind:
+		m.Data = &metricpb.Metric_IntHistogram{
+			IntHistogram: &metricpb.IntHistogram{
+				DataPoints: []*metricpb.IntHistogramDataPoint{
+					{
+						Sum:               sum.CoerceToInt64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(record.StartTime()),
+						TimeUnixNano:      toNanos(record.EndTime()),
+						Count:             uint64(count),
+						BucketCounts:      buckets,
+						ExplicitBounds:    bounds,
+					},
+				},
+			},
+		}
+	case number.Float64Kind:
+		m.Data = &metricpb.Metric_DoubleHistogram{
+			DoubleHistogram: &metricpb.DoubleHistogram{
+				DataPoints: []*metricpb.DoubleHistogramDataPoint{
+					{
+						Sum:               sum.CoerceToFloat64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(record.StartTime()),
+						TimeUnixNano:      toNanos(record.EndTime()),
+						Count:             uint64(count),
+						BucketCounts:      buckets,
+						ExplicitBounds:    bounds,
+					},
+				},
+			},
+		}
+	default:
+		return nil, fmt.Errorf("%w: %v", ErrUnknownValueType, n)
+	}
+	return m, nil
+}
+
+func histogramValues(a aggregation.Histogram) (boundaries []float64, counts []uint64, err error) {
+	var buckets aggregation.Buckets
+	if buckets, err = a.Histogram(); err != nil {
+		return
+	}
+	boundaries, counts = buckets.Boundaries, buckets.Counts
+	if len(counts) != len(boundaries)+1 {
+		err = ErrTransforming
+		return
+	}
+	return
+}
+
+// histogram transforms a Histogram Aggregator into an OTLP Metric.
+func histogramPoint(record export.Record, ek export.ExportKind, a aggregation.Histogram) (*metricpb.Metric, error) {
+	desc := record.Descriptor()
+	labels := record.Labels()
+	boundaries, counts, err := histogramValues(a)
+	if err != nil {
+		return nil, err
+	}
+
+	count, err := a.Count()
+	if err != nil {
+		return nil, err
+	}
+
+	sum, err := a.Sum()
+	if err != nil {
+		return nil, err
+	}
+
+	m := &metricpb.Metric{
+		Name:        desc.Name(),
+		Description: desc.Description(),
+		Unit:        string(desc.Unit()),
+	}
+	switch n := desc.NumberKind(); n {
+	case number.Int64Kind:
+		m.Data = &metricpb.Metric_IntHistogram{
+			IntHistogram: &metricpb.IntHistogram{
+				AggregationTemporality: exportKindToTemporality(ek),
+				DataPoints: []*metricpb.IntHistogramDataPoint{
+					{
+						Sum:               sum.CoerceToInt64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(record.StartTime()),
+						TimeUnixNano:      toNanos(record.EndTime()),
+						Count:             uint64(count),
+						BucketCounts:      counts,
+						ExplicitBounds:    boundaries,
+					},
+				},
+			},
+		}
+	case number.Float64Kind:
+		m.Data = &metricpb.Metric_DoubleHistogram{
+			DoubleHistogram: &metricpb.DoubleHistogram{
+				AggregationTemporality: exportKindToTemporality(ek),
+				DataPoints: []*metricpb.DoubleHistogramDataPoint{
+					{
+						Sum:               sum.CoerceToFloat64(n),
+						Labels:            stringKeyValues(labels.Iter()),
+						StartTimeUnixNano: toNanos(record.StartTime()),
+						TimeUnixNano:      toNanos(record.EndTime()),
+						Count:             uint64(count),
+						BucketCounts:      counts,
+						ExplicitBounds:    boundaries,
+					},
+				},
+			},
+		}
+	default:
+		return nil, fmt.Errorf("%w: %v", ErrUnknownValueType, n)
+	}
+
+	return m, nil
+}
+
+// stringKeyValues transforms a label iterator into an OTLP StringKeyValues.
+func stringKeyValues(iter attribute.Iterator) []*commonpb.StringKeyValue {
+	l := iter.Len()
+	if l == 0 {
+		return nil
+	}
+	result := make([]*commonpb.StringKeyValue, 0, l)
+	for iter.Next() {
+		kv := iter.Label()
+		result = append(result, &commonpb.StringKeyValue{
+			Key:   string(kv.Key),
+			Value: kv.Value.Emit(),
+		})
+	}
+	return result
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/transform/resource.go

@@ -0,0 +1,29 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transform
+
+import (
+	resourcepb "go.opentelemetry.io/proto/otlp/resource/v1"
+
+	"go.opentelemetry.io/otel/sdk/resource"
+)
+
+// Resource transforms a Resource into an OTLP Resource.
+func Resource(r *resource.Resource) *resourcepb.Resource {
+	if r == nil {
+		return nil
+	}
+	return &resourcepb.Resource{Attributes: ResourceAttributes(r)}
+}

vendor/go.opentelemetry.io/otel/exporters/otlp/internal/transform/span.go

@@ -0,0 +1,218 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transform
+
+import (
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/codes"
+	tracepb "go.opentelemetry.io/proto/otlp/trace/v1"
+
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+	tracesdk "go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/trace"
+)
+
+const (
+	maxMessageEventsPerSpan = 128
+)
+
+// SpanData transforms a slice of SpanSnapshot into a slice of OTLP
+// ResourceSpans.
+func SpanData(sdl []*tracesdk.SpanSnapshot) []*tracepb.ResourceSpans {
+	if len(sdl) == 0 {
+		return nil
+	}
+
+	rsm := make(map[attribute.Distinct]*tracepb.ResourceSpans)
+
+	type ilsKey struct {
+		r  attribute.Distinct
+		il instrumentation.Library
+	}
+	ilsm := make(map[ilsKey]*tracepb.InstrumentationLibrarySpans)
+
+	var resources int
+	for _, sd := range sdl {
+		if sd == nil {
+			continue
+		}
+
+		rKey := sd.Resource.Equivalent()
+		iKey := ilsKey{
+			r:  rKey,
+			il: sd.InstrumentationLibrary,
+		}
+		ils, iOk := ilsm[iKey]
+		if !iOk {
+			// Either the resource or instrumentation library were unknown.
+			ils = &tracepb.InstrumentationLibrarySpans{
+				InstrumentationLibrary: instrumentationLibrary(sd.InstrumentationLibrary),
+				Spans:                  []*tracepb.Span{},
+			}
+		}
+		ils.Spans = append(ils.Spans, span(sd))
+		ilsm[iKey] = ils
+
+		rs, rOk := rsm[rKey]
+		if !rOk {
+			resources++
+			// The resource was unknown.
+			rs = &tracepb.ResourceSpans{
+				Resource:                    Resource(sd.Resource),
+				InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ils},
+			}
+			rsm[rKey] = rs
+			continue
+		}
+
+		// The resource has been seen before. Check if the instrumentation
+		// library lookup was unknown because if so we need to add it to the
+		// ResourceSpans. Otherwise, the instrumentation library has already
+		// been seen and the append we did above will be included it in the
+		// InstrumentationLibrarySpans reference.
+		if !iOk {
+			rs.InstrumentationLibrarySpans = append(rs.InstrumentationLibrarySpans, ils)
+		}
+	}
+
+	// Transform the categorized map into a slice
+	rss := make([]*tracepb.ResourceSpans, 0, resources)
+	for _, rs := range rsm {
+		rss = append(rss, rs)
+	}
+	return rss
+}
+
+// span transforms a Span into an OTLP span.
+func span(sd *tracesdk.SpanSnapshot) *tracepb.Span {
+	if sd == nil {
+		return nil
+	}
+
+	tid := sd.SpanContext.TraceID()
+	sid := sd.SpanContext.SpanID()
+
+	s := &tracepb.Span{
+		TraceId:                tid[:],
+		SpanId:                 sid[:],
+		TraceState:             sd.SpanContext.TraceState().String(),
+		Status:                 status(sd.StatusCode, sd.StatusMessage),
+		StartTimeUnixNano:      uint64(sd.StartTime.UnixNano()),
+		EndTimeUnixNano:        uint64(sd.EndTime.UnixNano()),
+		Links:                  links(sd.Links),
+		Kind:                   spanKind(sd.SpanKind),
+		Name:                   sd.Name,
+		Attributes:             Attributes(sd.Attributes),
+		Events:                 spanEvents(sd.MessageEvents),
+		DroppedAttributesCount: uint32(sd.DroppedAttributeCount),
+		DroppedEventsCount:     uint32(sd.DroppedMessageEventCount),
+		DroppedLinksCount:      uint32(sd.DroppedLinkCount),
+	}
+
+	if psid := sd.Parent.SpanID(); psid.IsValid() {
+		s.ParentSpanId = psid[:]
+	}
+
+	return s
+}
+
+// status transform a span code and message into an OTLP span status.
+func status(status codes.Code, message string) *tracepb.Status {
+	var c tracepb.Status_StatusCode
+	switch status {
+	case codes.Error:
+		c = tracepb.Status_STATUS_CODE_ERROR
+	default:
+		c = tracepb.Status_STATUS_CODE_OK
+	}
+	return &tracepb.Status{
+		Code:    c,
+		Message: message,
+	}
+}
+
+// links transforms span Links to OTLP span links.
+func links(links []trace.Link) []*tracepb.Span_Link {
+	if len(links) == 0 {
+		return nil
+	}
+
+	sl := make([]*tracepb.Span_Link, 0, len(links))
+	for _, otLink := range links {
+		// This redefinition is necessary to prevent otLink.*ID[:] copies
+		// being reused -- in short we need a new otLink per iteration.
+		otLink := otLink
+
+		tid := otLink.TraceID()
+		sid := otLink.SpanID()
+
+		sl = append(sl, &tracepb.Span_Link{
+			TraceId:    tid[:],
+			SpanId:     sid[:],
+			Attributes: Attributes(otLink.Attributes),
+		})
+	}
+	return sl
+}
+
+// spanEvents transforms span Events to an OTLP span events.
+func spanEvents(es []trace.Event) []*tracepb.Span_Event {
+	if len(es) == 0 {
+		return nil
+	}
+
+	evCount := len(es)
+	if evCount > maxMessageEventsPerSpan {
+		evCount = maxMessageEventsPerSpan
+	}
+	events := make([]*tracepb.Span_Event, 0, evCount)
+	messageEvents := 0
+
+	// Transform message events
+	for _, e := range es {
+		if messageEvents >= maxMessageEventsPerSpan {
+			break
+		}
+		messageEvents++
+		events = append(events,
+			&tracepb.Span_Event{
+				Name:         e.Name,
+				TimeUnixNano: uint64(e.Time.UnixNano()),
+				Attributes:   Attributes(e.Attributes),
+				// TODO (rghetia) : Add Drop Counts when supported.
+			},
+		)
+	}
+
+	return events
+}
+
+// spanKind transforms a SpanKind to an OTLP span kind.
+func spanKind(kind trace.SpanKind) tracepb.Span_SpanKind {
+	switch kind {
+	case trace.SpanKindInternal:
+		return tracepb.Span_SPAN_KIND_INTERNAL
+	case trace.SpanKindClient:
+		return tracepb.Span_SPAN_KIND_CLIENT
+	case trace.SpanKindServer:
+		return tracepb.Span_SPAN_KIND_SERVER
+	case trace.SpanKindProducer:
+		return tracepb.Span_SPAN_KIND_PRODUCER
+	case trace.SpanKindConsumer:
+		return tracepb.Span_SPAN_KIND_CONSUMER
+	default:
+		return tracepb.Span_SPAN_KIND_UNSPECIFIED
+	}
+}