vendor: update buildkit

Signed-off-by: CrazyMax <crazy-max@users.noreply.github.com>

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

@@ -16,66 +16,59 @@ package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/
 
 import (
 	"crypto/tls"
-	"fmt"
-	"io/ioutil"
+	"crypto/x509"
 	"net/url"
 	"os"
 	"path"
-	"strconv"
 	"strings"
 	"time"
 
-	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/exporters/otlp/internal/envconfig"
 )
 
-var DefaultEnvOptionsReader = EnvOptionsReader{
-	GetEnv:   os.Getenv,
-	ReadFile: ioutil.ReadFile,
+// DefaultEnvOptionsReader is the default environments reader.
+var DefaultEnvOptionsReader = envconfig.EnvOptionsReader{
+	GetEnv:    os.Getenv,
+	ReadFile:  os.ReadFile,
+	Namespace: "OTEL_EXPORTER_OTLP",
 }
 
+// ApplyGRPCEnvConfigs applies the env configurations for gRPC.
 func ApplyGRPCEnvConfigs(cfg Config) Config {
-	return DefaultEnvOptionsReader.ApplyGRPCEnvConfigs(cfg)
-}
-
-func ApplyHTTPEnvConfigs(cfg Config) Config {
-	return DefaultEnvOptionsReader.ApplyHTTPEnvConfigs(cfg)
-}
-
-type EnvOptionsReader struct {
-	GetEnv   func(string) string
-	ReadFile func(filename string) ([]byte, error)
-}
-
-func (e *EnvOptionsReader) ApplyHTTPEnvConfigs(cfg Config) Config {
-	opts := e.GetOptionsFromEnv()
-	for _, opt := range opts {
-		cfg = opt.ApplyHTTPOption(cfg)
-	}
-	return cfg
-}
-
-func (e *EnvOptionsReader) ApplyGRPCEnvConfigs(cfg Config) Config {
-	opts := e.GetOptionsFromEnv()
+	opts := getOptionsFromEnv()
 	for _, opt := range opts {
 		cfg = opt.ApplyGRPCOption(cfg)
 	}
 	return cfg
 }
 
-func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
-	var opts []GenericOption
+// ApplyHTTPEnvConfigs applies the env configurations for HTTP.
+func ApplyHTTPEnvConfigs(cfg Config) Config {
+	opts := getOptionsFromEnv()
+	for _, opt := range opts {
+		cfg = opt.ApplyHTTPOption(cfg)
+	}
+	return cfg
+}
 
-	// Endpoint
-	if v, ok := e.getEnvValue("TRACES_ENDPOINT"); ok {
-		u, err := url.Parse(v)
-		// Ignore invalid values.
-		if err == nil {
-			// This is used to set the scheme for OTLP/HTTP.
-			if insecureSchema(u.Scheme) {
-				opts = append(opts, WithInsecure())
-			} else {
-				opts = append(opts, WithSecure())
-			}
+func getOptionsFromEnv() []GenericOption {
+	opts := []GenericOption{}
+
+	tlsConf := &tls.Config{}
+	DefaultEnvOptionsReader.Apply(
+		envconfig.WithURL("ENDPOINT", func(u *url.URL) {
+			opts = append(opts, withEndpointScheme(u))
+			opts = append(opts, newSplitOption(func(cfg Config) Config {
+				cfg.Traces.Endpoint = u.Host
+				// For OTLP/HTTP endpoint URLs without a per-signal
+				// configuration, the passed endpoint is used as a base URL
+				// and the signals are sent to these paths relative to that.
+				cfg.Traces.URLPath = path.Join(u.Path, DefaultTracesPath)
+				return cfg
+			}, withEndpointForGRPC(u)))
+		}),
+		envconfig.WithURL("TRACES_ENDPOINT", func(u *url.URL) {
+			opts = append(opts, withEndpointScheme(u))
 			opts = append(opts, newSplitOption(func(cfg Config) Config {
 				cfg.Traces.Endpoint = u.Host
 				// For endpoint URLs for OTLP/HTTP per-signal variables, the
@@ -88,140 +81,70 @@ func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
 				}
 				cfg.Traces.URLPath = path
 				return cfg
-			}, func(cfg Config) Config {
-				// For OTLP/gRPC endpoints, this is the target to which the
-				// exporter is going to send telemetry.
-				cfg.Traces.Endpoint = path.Join(u.Host, u.Path)
-				return cfg
-			}))
-		}
-	} else if v, ok = e.getEnvValue("ENDPOINT"); ok {
-		u, err := url.Parse(v)
-		// Ignore invalid values.
-		if err == nil {
-			// This is used to set the scheme for OTLP/HTTP.
-			if insecureSchema(u.Scheme) {
-				opts = append(opts, WithInsecure())
-			} else {
-				opts = append(opts, WithSecure())
-			}
-			opts = append(opts, newSplitOption(func(cfg Config) Config {
-				cfg.Traces.Endpoint = u.Host
-				// For OTLP/HTTP endpoint URLs without a per-signal
-				// configuration, the passed endpoint is used as a base URL
-				// and the signals are sent to these paths relative to that.
-				cfg.Traces.URLPath = path.Join(u.Path, DefaultTracesPath)
-				return cfg
-			}, func(cfg Config) Config {
-				// For OTLP/gRPC endpoints, this is the target to which the
-				// exporter is going to send telemetry.
-				cfg.Traces.Endpoint = path.Join(u.Host, u.Path)
-				return cfg
-			}))
-		}
-	}
-
-	// 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, WithTLSClientConfig(tls))
-		} else {
-			otel.Handle(fmt.Errorf("failed to configure otlp traces 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, WithHeaders(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, WithCompression(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, WithTimeout(time.Duration(d)*time.Millisecond))
-		}
-	}
+			}, withEndpointForGRPC(u)))
+		}),
+		envconfig.WithCertPool("CERTIFICATE", func(p *x509.CertPool) { tlsConf.RootCAs = p }),
+		envconfig.WithCertPool("TRACES_CERTIFICATE", func(p *x509.CertPool) { tlsConf.RootCAs = p }),
+		envconfig.WithClientCert("CLIENT_CERTIFICATE", "CLIENT_KEY", func(c tls.Certificate) { tlsConf.Certificates = []tls.Certificate{c} }),
+		envconfig.WithClientCert("TRACES_CLIENT_CERTIFICATE", "TRACES_CLIENT_KEY", func(c tls.Certificate) { tlsConf.Certificates = []tls.Certificate{c} }),
+		withTLSConfig(tlsConf, func(c *tls.Config) { opts = append(opts, WithTLSClientConfig(c)) }),
+		envconfig.WithBool("INSECURE", func(b bool) { opts = append(opts, withInsecure(b)) }),
+		envconfig.WithBool("TRACES_INSECURE", func(b bool) { opts = append(opts, withInsecure(b)) }),
+		envconfig.WithHeaders("HEADERS", func(h map[string]string) { opts = append(opts, WithHeaders(h)) }),
+		envconfig.WithHeaders("TRACES_HEADERS", func(h map[string]string) { opts = append(opts, WithHeaders(h)) }),
+		WithEnvCompression("COMPRESSION", func(c Compression) { opts = append(opts, WithCompression(c)) }),
+		WithEnvCompression("TRACES_COMPRESSION", func(c Compression) { opts = append(opts, WithCompression(c)) }),
+		envconfig.WithDuration("TIMEOUT", func(d time.Duration) { opts = append(opts, WithTimeout(d)) }),
+		envconfig.WithDuration("TRACES_TIMEOUT", func(d time.Duration) { opts = append(opts, WithTimeout(d)) }),
+	)
 
 	return opts
 }
 
-func insecureSchema(schema string) bool {
-	switch strings.ToLower(schema) {
+func withEndpointScheme(u *url.URL) GenericOption {
+	switch strings.ToLower(u.Scheme) {
 	case "http", "unix":
-		return true
+		return WithInsecure()
 	default:
-		return false
+		return WithSecure()
 	}
 }
 
-// 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
+func withEndpointForGRPC(u *url.URL) func(cfg Config) Config {
+	return func(cfg Config) Config {
+		// For OTLP/gRPC endpoints, this is the target to which the
+		// exporter is going to send telemetry.
+		cfg.Traces.Endpoint = path.Join(u.Host, u.Path)
+		return cfg
 	}
-	return CreateTLSConfig(b)
 }
 
-func stringToCompression(value string) Compression {
-	switch value {
-	case "gzip":
-		return GzipCompression
-	}
+// WithEnvCompression retrieves the specified config and passes it to ConfigFn as a Compression.
+func WithEnvCompression(n string, fn func(Compression)) func(e *envconfig.EnvOptionsReader) {
+	return func(e *envconfig.EnvOptionsReader) {
+		if v, ok := e.GetEnvValue(n); ok {
+			cp := NoCompression
+			if v == "gzip" {
+				cp = GzipCompression
+			}
 
-	return 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
+			fn(cp)
+		}
+	}
+}
+
+// revive:disable-next-line:flag-parameter
+func withInsecure(b bool) GenericOption {
+	if b {
+		return WithInsecure()
+	}
+	return WithSecure()
+}
+
+func withTLSConfig(c *tls.Config, fn func(*tls.Config)) func(e *envconfig.EnvOptionsReader) {
+	return func(e *envconfig.EnvOptionsReader) {
+		if c.RootCAs != nil || len(c.Certificates) > 0 {
+			fn(c)
 		}
-		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/otlptrace/internal/otlpconfig/options.go

@@ -25,6 +25,7 @@ import (
 	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/encoding/gzip"
 
+	"go.opentelemetry.io/otel/exporters/otlp/internal"
 	"go.opentelemetry.io/otel/exporters/otlp/internal/retry"
 )
 
@@ -65,24 +66,39 @@ type (
 	}
 )
 
-func NewDefaultConfig() Config {
-	c := Config{
+// NewHTTPConfig returns a new Config with all settings applied from opts and
+// any unset setting using the default HTTP config values.
+func NewHTTPConfig(opts ...HTTPOption) Config {
+	cfg := Config{
 		Traces: SignalConfig{
-			Endpoint:    fmt.Sprintf("%s:%d", DefaultCollectorHost, DefaultCollectorPort),
+			Endpoint:    fmt.Sprintf("%s:%d", DefaultCollectorHost, DefaultCollectorHTTPPort),
 			URLPath:     DefaultTracesPath,
 			Compression: NoCompression,
 			Timeout:     DefaultTimeout,
 		},
 		RetryConfig: retry.DefaultConfig,
 	}
-
-	return c
+	cfg = ApplyHTTPEnvConfigs(cfg)
+	for _, opt := range opts {
+		cfg = opt.ApplyHTTPOption(cfg)
+	}
+	cfg.Traces.URLPath = internal.CleanPath(cfg.Traces.URLPath, DefaultTracesPath)
+	return cfg
 }
 
 // NewGRPCConfig returns a new Config with all settings applied from opts and
 // any unset setting using the default gRPC config values.
 func NewGRPCConfig(opts ...GRPCOption) Config {
-	cfg := NewDefaultConfig()
+	cfg := Config{
+		Traces: SignalConfig{
+			Endpoint:    fmt.Sprintf("%s:%d", DefaultCollectorHost, DefaultCollectorGRPCPort),
+			URLPath:     DefaultTracesPath,
+			Compression: NoCompression,
+			Timeout:     DefaultTimeout,
+		},
+		RetryConfig: retry.DefaultConfig,
+		DialOptions: []grpc.DialOption{grpc.WithUserAgent(internal.GetUserAgentHeader())},
+	}
 	cfg = ApplyGRPCEnvConfigs(cfg)
 	for _, opt := range opts {
 		cfg = opt.ApplyGRPCOption(cfg)

vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig/optiontypes.go

@@ -15,9 +15,10 @@
 package otlpconfig // import "go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig"
 
 const (
-	// DefaultCollectorPort is the port the Exporter will attempt connect to
-	// if no collector port is provided.
-	DefaultCollectorPort uint16 = 4317
+	// DefaultCollectorGRPCPort is the default gRPC port of the collector.
+	DefaultCollectorGRPCPort uint16 = 4317
+	// DefaultCollectorHTTPPort is the default HTTP port of the collector.
+	DefaultCollectorHTTPPort uint16 = 4318
 	// DefaultCollectorHost is the host address the Exporter will attempt
 	// connect to if no collector address is provided.
 	DefaultCollectorHost string = "localhost"
@@ -36,7 +37,7 @@ const (
 	GzipCompression
 )
 
-// Marshaler describes the kind of message format sent to the collector
+// Marshaler describes the kind of message format sent to the collector.
 type Marshaler int
 
 const (

vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/attribute.go

@@ -48,8 +48,8 @@ func Iterator(iter attribute.Iterator) []*commonpb.KeyValue {
 }
 
 // ResourceAttributes transforms a Resource OTLP key-values.
-func ResourceAttributes(resource *resource.Resource) []*commonpb.KeyValue {
-	return Iterator(resource.Iter())
+func ResourceAttributes(res *resource.Resource) []*commonpb.KeyValue {
+	return Iterator(res.Iter())
 }
 
 // KeyValue transforms an attribute KeyValue into an OTLP key-value.

vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/instrumentation.go

@@ -19,11 +19,11 @@ import (
 	commonpb "go.opentelemetry.io/proto/otlp/common/v1"
 )
 
-func InstrumentationLibrary(il instrumentation.Library) *commonpb.InstrumentationLibrary {
-	if il == (instrumentation.Library{}) {
+func InstrumentationScope(il instrumentation.Scope) *commonpb.InstrumentationScope {
+	if il == (instrumentation.Scope{}) {
 		return nil
 	}
-	return &commonpb.InstrumentationLibrary{
+	return &commonpb.InstrumentationScope{
 		Name:    il.Name,
 		Version: il.Version,
 	}

vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform/span.go

@@ -23,10 +23,6 @@ import (
 	tracepb "go.opentelemetry.io/proto/otlp/trace/v1"
 )
 
-const (
-	maxEventsPerSpan = 128
-)
-
 // Spans transforms a slice of OpenTelemetry spans into a slice of OTLP
 // ResourceSpans.
 func Spans(sdl []tracesdk.ReadOnlySpan) []*tracepb.ResourceSpans {
@@ -36,11 +32,11 @@ func Spans(sdl []tracesdk.ReadOnlySpan) []*tracepb.ResourceSpans {
 
 	rsm := make(map[attribute.Distinct]*tracepb.ResourceSpans)
 
-	type ilsKey struct {
+	type key struct {
 		r  attribute.Distinct
-		il instrumentation.Library
+		is instrumentation.Scope
 	}
-	ilsm := make(map[ilsKey]*tracepb.InstrumentationLibrarySpans)
+	ssm := make(map[key]*tracepb.ScopeSpans)
 
 	var resources int
 	for _, sd := range sdl {
@@ -49,30 +45,30 @@ func Spans(sdl []tracesdk.ReadOnlySpan) []*tracepb.ResourceSpans {
 		}
 
 		rKey := sd.Resource().Equivalent()
-		iKey := ilsKey{
+		k := key{
 			r:  rKey,
-			il: sd.InstrumentationLibrary(),
+			is: sd.InstrumentationScope(),
 		}
-		ils, iOk := ilsm[iKey]
+		scopeSpan, iOk := ssm[k]
 		if !iOk {
-			// Either the resource or instrumentation library were unknown.
-			ils = &tracepb.InstrumentationLibrarySpans{
-				InstrumentationLibrary: InstrumentationLibrary(sd.InstrumentationLibrary()),
-				Spans:                  []*tracepb.Span{},
-				SchemaUrl:              sd.InstrumentationLibrary().SchemaURL,
+			// Either the resource or instrumentation scope were unknown.
+			scopeSpan = &tracepb.ScopeSpans{
+				Scope:     InstrumentationScope(sd.InstrumentationScope()),
+				Spans:     []*tracepb.Span{},
+				SchemaUrl: sd.InstrumentationScope().SchemaURL,
 			}
 		}
-		ils.Spans = append(ils.Spans, span(sd))
-		ilsm[iKey] = ils
+		scopeSpan.Spans = append(scopeSpan.Spans, span(sd))
+		ssm[k] = scopeSpan
 
 		rs, rOk := rsm[rKey]
 		if !rOk {
 			resources++
 			// The resource was unknown.
 			rs = &tracepb.ResourceSpans{
-				Resource:                    Resource(sd.Resource()),
-				InstrumentationLibrarySpans: []*tracepb.InstrumentationLibrarySpans{ils},
-				SchemaUrl:                   sd.Resource().SchemaURL(),
+				Resource:   Resource(sd.Resource()),
+				ScopeSpans: []*tracepb.ScopeSpans{scopeSpan},
+				SchemaUrl:  sd.Resource().SchemaURL(),
 			}
 			rsm[rKey] = rs
 			continue
@@ -82,9 +78,9 @@ func Spans(sdl []tracesdk.ReadOnlySpan) []*tracepb.ResourceSpans {
 		// 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.
+		// ScopeSpans reference.
 		if !iOk {
-			rs.InstrumentationLibrarySpans = append(rs.InstrumentationLibrarySpans, ils)
+			rs.ScopeSpans = append(rs.ScopeSpans, scopeSpan)
 		}
 	}
 
@@ -162,9 +158,10 @@ func links(links []tracesdk.Link) []*tracepb.Span_Link {
 		sid := otLink.SpanContext.SpanID()
 
 		sl = append(sl, &tracepb.Span_Link{
-			TraceId:    tid[:],
-			SpanId:     sid[:],
-			Attributes: KeyValues(otLink.Attributes),
+			TraceId:                tid[:],
+			SpanId:                 sid[:],
+			Attributes:             KeyValues(otLink.Attributes),
+			DroppedAttributesCount: uint32(otLink.DroppedAttributeCount),
 		})
 	}
 	return sl
@@ -176,29 +173,16 @@ func spanEvents(es []tracesdk.Event) []*tracepb.Span_Event {
 		return nil
 	}
 
-	evCount := len(es)
-	if evCount > maxEventsPerSpan {
-		evCount = maxEventsPerSpan
-	}
-	events := make([]*tracepb.Span_Event, 0, evCount)
-	nEvents := 0
-
+	events := make([]*tracepb.Span_Event, len(es))
 	// Transform message events
-	for _, e := range es {
-		if nEvents >= maxEventsPerSpan {
-			break
+	for i := 0; i < len(es); i++ {
+		events[i] = &tracepb.Span_Event{
+			Name:                   es[i].Name,
+			TimeUnixNano:           uint64(es[i].Time.UnixNano()),
+			Attributes:             KeyValues(es[i].Attributes),
+			DroppedAttributesCount: uint32(es[i].DroppedAttributeCount),
 		}
-		nEvents++
-		events = append(events,
-			&tracepb.Span_Event{
-				Name:         e.Name,
-				TimeUnixNano: uint64(e.Time.UnixNano()),
-				Attributes:   KeyValues(e.Attributes),
-				// TODO (rghetia) : Add Drop Counts when supported.
-			},
-		)
 	}
-
 	return events
 }