vendor: update buildkit to opentelemetry support

Signed-off-by: Tonis Tiigi <tonistiigi@gmail.com>

vendor/github.com/moby/buildkit/util/tracing/detect/delegated/delegated.go

@@ -0,0 +1,75 @@
+package jaeger
+
+import (
+	"context"
+	"sync"
+
+	"github.com/moby/buildkit/util/tracing/detect"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+)
+
+const maxBuffer = 256
+
+var exp = &Exporter{}
+
+func init() {
+	detect.Register("delegated", func() (sdktrace.SpanExporter, error) {
+		return exp, nil
+	}, 100)
+}
+
+type Exporter struct {
+	mu        sync.Mutex
+	exporters []sdktrace.SpanExporter
+	buffer    []sdktrace.ReadOnlySpan
+}
+
+var _ sdktrace.SpanExporter = &Exporter{}
+
+func (e *Exporter) ExportSpans(ctx context.Context, ss []sdktrace.ReadOnlySpan) error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	var err error
+	for _, e := range e.exporters {
+		if err1 := e.ExportSpans(ctx, ss); err1 != nil {
+			err = err1
+		}
+	}
+	if err != nil {
+		return err
+	}
+
+	if len(e.buffer) > maxBuffer {
+		return nil
+	}
+
+	e.buffer = append(e.buffer, ss...)
+	return nil
+}
+
+func (e *Exporter) Shutdown(ctx context.Context) error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	var err error
+	for _, e := range e.exporters {
+		if err1 := e.Shutdown(ctx); err1 != nil {
+			err = err1
+		}
+	}
+
+	return err
+}
+
+func (e *Exporter) SetSpanExporter(ctx context.Context, exp sdktrace.SpanExporter) error {
+	e.mu.Lock()
+	defer e.mu.Unlock()
+
+	e.exporters = append(e.exporters, exp)
+
+	if len(e.buffer) > 0 {
+		return exp.ExportSpans(ctx, e.buffer)
+	}
+	return nil
+}

vendor/github.com/moby/buildkit/util/tracing/detect/detect.go

@@ -0,0 +1,150 @@
+package detect
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"sync"
+
+	"github.com/pkg/errors"
+	"go.opentelemetry.io/otel/sdk/resource"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
+	"go.opentelemetry.io/otel/trace"
+)
+
+type ExporterDetector func() (sdktrace.SpanExporter, error)
+
+type detector struct {
+	f        ExporterDetector
+	priority int
+}
+
+var ServiceName string
+
+var detectors map[string]detector
+var once sync.Once
+var tp trace.TracerProvider
+var exporter sdktrace.SpanExporter
+var closers []func(context.Context) error
+var err error
+
+func Register(name string, exp ExporterDetector, priority int) {
+	if detectors == nil {
+		detectors = map[string]detector{}
+	}
+	detectors[name] = detector{
+		f:        exp,
+		priority: priority,
+	}
+}
+
+func detectExporter() (sdktrace.SpanExporter, error) {
+	if n := os.Getenv("OTEL_TRACES_EXPORTER"); n != "" {
+		d, ok := detectors[n]
+		if !ok {
+			if n == "none" {
+				return nil, nil
+			}
+			return nil, errors.Errorf("unsupported opentelemetry tracer %v", n)
+		}
+		return d.f()
+	}
+	arr := make([]detector, 0, len(detectors))
+	for _, d := range detectors {
+		arr = append(arr, d)
+	}
+	sort.Slice(arr, func(i, j int) bool {
+		return arr[i].priority < arr[j].priority
+	})
+	for _, d := range arr {
+		exp, err := d.f()
+		if err != nil {
+			return nil, err
+		}
+		if exp != nil {
+			return exp, nil
+		}
+	}
+	return nil, nil
+}
+
+func detect() error {
+	tp = trace.NewNoopTracerProvider()
+
+	exp, err := detectExporter()
+	if err != nil {
+		return err
+	}
+
+	if exp == nil {
+		return nil
+	}
+	res, err := resource.Detect(context.Background(), serviceNameDetector{})
+	if err != nil {
+		return err
+	}
+	res, err = resource.Merge(resource.Default(), res)
+	if err != nil {
+		return err
+	}
+
+	sp := sdktrace.NewBatchSpanProcessor(exp)
+
+	sdktp := sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sp), sdktrace.WithResource(res))
+	closers = append(closers, sdktp.Shutdown)
+
+	exporter = exp
+	tp = sdktp
+	return nil
+}
+
+func TracerProvider() (trace.TracerProvider, error) {
+	once.Do(func() {
+		if err1 := detect(); err1 != nil {
+			err = err1
+		}
+	})
+	b, _ := strconv.ParseBool(os.Getenv("OTEL_INGORE_ERROR"))
+	if err != nil && !b {
+		return nil, err
+	}
+	return tp, nil
+}
+
+func Exporter() (sdktrace.SpanExporter, error) {
+	_, err := TracerProvider()
+	if err != nil {
+		return nil, err
+	}
+	return exporter, nil
+}
+
+func Shutdown(ctx context.Context) error {
+	for _, c := range closers {
+		if err := c(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+type serviceNameDetector struct{}
+
+func (serviceNameDetector) Detect(ctx context.Context) (*resource.Resource, error) {
+	return resource.StringDetector(
+		semconv.SchemaURL,
+		semconv.ServiceNameKey,
+		func() (string, error) {
+			if n := os.Getenv("OTEL_SERVICE_NAME"); n != "" {
+				return n, nil
+			}
+			if ServiceName != "" {
+				return ServiceName, nil
+			}
+			return filepath.Base(os.Args[0]), nil
+		},
+	).Detect(ctx)
+}

vendor/github.com/moby/buildkit/util/tracing/detect/otlp.go

@@ -0,0 +1,45 @@
+package detect
+
+import (
+	"context"
+	"os"
+
+	"github.com/pkg/errors"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+)
+
+func init() {
+	Register("otlp", otlpExporter, 10)
+}
+
+func otlpExporter() (sdktrace.SpanExporter, error) {
+	set := os.Getenv("OTEL_TRACES_EXPORTER") == "otpl" || os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") != "" || os.Getenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") != ""
+	if !set {
+		return nil, nil
+	}
+
+	proto := os.Getenv("OTEL_EXPORTER_OTLP_TRACES_PROTOCOL")
+	if proto == "" {
+		proto = os.Getenv("OTEL_EXPORTER_OTLP_PROTOCOL")
+	}
+	if proto == "" {
+		proto = "grpc"
+	}
+
+	var c otlptrace.Client
+
+	switch proto {
+	case "grpc":
+		c = otlptracegrpc.NewClient()
+	case "http/protobuf":
+		c = otlptracehttp.NewClient()
+	// case "http/json": // unsupported by library
+	default:
+		return nil, errors.Errorf("unsupported otlp protocol %v", proto)
+	}
+
+	return otlptrace.New(context.Background(), c)
+}