deps: update buildkit, vendor changes

Signed-off-by: Laura Brehm <laurabrehm@hey.com>

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

@@ -5,6 +5,7 @@ import (
 	"sync"
 
 	"github.com/moby/buildkit/util/tracing/detect"
+	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 )
 
@@ -13,8 +14,8 @@ const maxBuffer = 256
 var exp = &Exporter{}
 
 func init() {
-	detect.Register("delegated", func() (sdktrace.SpanExporter, error) {
-		return exp, nil
+	detect.Register("delegated", func() (sdktrace.SpanExporter, sdkmetric.Exporter, error) {
+		return exp, nil, nil
 	}, 100)
 }
 

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

@@ -10,13 +10,16 @@ import (
 
 	"github.com/moby/buildkit/util/bklog"
 	"github.com/pkg/errors"
+	"go.opentelemetry.io/otel/exporters/prometheus"
+	"go.opentelemetry.io/otel/metric"
+	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
 	"go.opentelemetry.io/otel/sdk/resource"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 	semconv "go.opentelemetry.io/otel/semconv/v1.21.0"
 	"go.opentelemetry.io/otel/trace"
 )
 
-type ExporterDetector func() (sdktrace.SpanExporter, error)
+type ExporterDetector func() (sdktrace.SpanExporter, sdkmetric.Exporter, error)
 
 type detector struct {
 	f        ExporterDetector
@@ -26,10 +29,16 @@ type detector struct {
 var ServiceName string
 var Recorder *TraceRecorder
 
+var Resource *resource.Resource
+
 var detectors map[string]detector
 var once sync.Once
 var tp trace.TracerProvider
-var exporter sdktrace.SpanExporter
+var mp metric.MeterProvider
+var exporter struct {
+	SpanExporter   sdktrace.SpanExporter
+	MetricExporter sdkmetric.Exporter
+}
 var closers []func(context.Context) error
 var err error
 
@@ -43,14 +52,14 @@ func Register(name string, exp ExporterDetector, priority int) {
 	}
 }
 
-func detectExporter() (sdktrace.SpanExporter, error) {
+func detectExporter() (texp sdktrace.SpanExporter, mexp sdkmetric.Exporter, err error) {
 	if n := os.Getenv("OTEL_TRACES_EXPORTER"); n != "" {
 		d, ok := detectors[n]
 		if !ok {
 			if n == "none" {
-				return nil, nil
+				return nil, nil, nil
 			}
-			return nil, errors.Errorf("unsupported opentelemetry tracer %v", n)
+			return nil, nil, errors.Errorf("unsupported opentelemetry tracer %v", n)
 		}
 		return d.f()
 	}
@@ -61,84 +70,145 @@ func detectExporter() (sdktrace.SpanExporter, error) {
 	sort.Slice(arr, func(i, j int) bool {
 		return arr[i].priority < arr[j].priority
 	})
+
 	for _, d := range arr {
-		exp, err := d.f()
+		t, m, err := d.f()
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
-		if exp != nil {
-			return exp, nil
+		if texp == nil {
+			texp = t
+		}
+		if mexp == nil {
+			mexp = m
+		}
+
+		// Found a candidate for both exporters so just return now.
+		if texp != nil && mexp != nil {
+			return texp, mexp, nil
 		}
 	}
-	return nil, nil
+	return texp, mexp, nil
 }
 
-func getExporter() (sdktrace.SpanExporter, error) {
-	exp, err := detectExporter()
+func getExporters() (sdktrace.SpanExporter, sdkmetric.Exporter, error) {
+	texp, mexp, err := detectExporter()
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
 	if Recorder != nil {
-		Recorder.SpanExporter = exp
-		exp = Recorder
+		Recorder.SpanExporter = texp
+		texp = Recorder
 	}
-	return exp, nil
+
+	return texp, mexp, nil
 }
 
 func detect() error {
 	tp = trace.NewNoopTracerProvider()
+	mp = sdkmetric.NewMeterProvider()
 
-	exp, err := getExporter()
-	if err != nil || exp == nil {
+	texp, mexp, err := getExporters()
+	if err != nil || (texp == nil && mexp == nil) {
 		return err
 	}
 
+	if Resource == 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
+		}
+		Resource = res
+	}
+
 	// enable log with traceID when valid exporter
-	bklog.EnableLogWithTraceID(true)
+	if texp != nil {
+		bklog.EnableLogWithTraceID(true)
 
-	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(texp)
+
+		if Recorder != nil {
+			Recorder.flush = sp.ForceFlush
+		}
+
+		sdktp := sdktrace.NewTracerProvider(
+			sdktrace.WithSpanProcessor(sp),
+			sdktrace.WithResource(Resource),
+		)
+		closers = append(closers, sdktp.Shutdown)
+
+		exporter.SpanExporter = texp
+		tp = sdktp
 	}
 
-	sp := sdktrace.NewBatchSpanProcessor(exp)
-
-	if Recorder != nil {
-		Recorder.flush = sp.ForceFlush
+	var readers []sdkmetric.Reader
+	if mexp != nil {
+		// Create a new periodic reader using any configured metric exporter.
+		readers = append(readers, sdkmetric.NewPeriodicReader(mexp))
 	}
 
-	sdktp := sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sp), sdktrace.WithResource(res))
-	closers = append(closers, sdktp.Shutdown)
+	if r, err := prometheus.New(); err != nil {
+		// Log the error but do not fail if we could not configure the prometheus metrics.
+		bklog.G(context.Background()).
+			WithError(err).
+			Error("failed prometheus metrics configuration")
+	} else {
+		// Register the prometheus reader if there was no error.
+		readers = append(readers, r)
+	}
 
-	exporter = exp
-	tp = sdktp
+	if len(readers) > 0 {
+		opts := make([]sdkmetric.Option, 0, len(readers)+1)
+		opts = append(opts, sdkmetric.WithResource(Resource))
+		for _, r := range readers {
+			opts = append(opts, sdkmetric.WithReader(r))
+		}
+		sdkmp := sdkmetric.NewMeterProvider(opts...)
+		closers = append(closers, sdkmp.Shutdown)
+
+		exporter.MetricExporter = mexp
+		mp = sdkmp
+	}
 	return nil
 }
 
 func TracerProvider() (trace.TracerProvider, error) {
-	once.Do(func() {
-		if err1 := detect(); err1 != nil {
-			err = err1
-		}
-	})
-	b, _ := strconv.ParseBool(os.Getenv("OTEL_IGNORE_ERROR"))
-	if err != nil && !b {
+	if err := detectOnce(); err != nil {
 		return nil, err
 	}
 	return tp, nil
 }
 
-func Exporter() (sdktrace.SpanExporter, error) {
-	_, err := TracerProvider()
-	if err != nil {
+func MeterProvider() (metric.MeterProvider, error) {
+	if err := detectOnce(); err != nil {
 		return nil, err
 	}
-	return exporter, nil
+	return mp, nil
+}
+
+func detectOnce() error {
+	once.Do(func() {
+		if err1 := detect(); err1 != nil {
+			b, _ := strconv.ParseBool(os.Getenv("OTEL_IGNORE_ERROR"))
+			if !b {
+				err = err1
+			}
+		}
+	})
+	return err
+}
+
+func Exporter() (sdktrace.SpanExporter, sdkmetric.Exporter, error) {
+	_, err := TracerProvider()
+	if err != nil {
+		return nil, nil, err
+	}
+	return exporter.SpanExporter, exporter.MetricExporter, nil
 }
 
 func Shutdown(ctx context.Context) error {

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

@@ -5,9 +5,13 @@ import (
 	"os"
 
 	"github.com/pkg/errors"
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc"
+	"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc"
 	"go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp"
+	sdkmetric "go.opentelemetry.io/otel/sdk/metric"
+	"go.opentelemetry.io/otel/sdk/metric/metricdata"
 	sdktrace "go.opentelemetry.io/otel/sdk/trace"
 )
 
@@ -15,7 +19,20 @@ func init() {
 	Register("otlp", otlpExporter, 10)
 }
 
-func otlpExporter() (sdktrace.SpanExporter, error) {
+func otlpExporter() (sdktrace.SpanExporter, sdkmetric.Exporter, error) {
+	texp, err := otlpSpanExporter()
+	if err != nil {
+		return nil, nil, err
+	}
+
+	mexp, err := otlpMetricExporter()
+	if err != nil {
+		return nil, nil, err
+	}
+	return texp, mexp, nil
+}
+
+func otlpSpanExporter() (sdktrace.SpanExporter, error) {
 	set := os.Getenv("OTEL_TRACES_EXPORTER") == "otlp" || os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") != "" || os.Getenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT") != ""
 	if !set {
 		return nil, nil
@@ -43,3 +60,36 @@ func otlpExporter() (sdktrace.SpanExporter, error) {
 
 	return otlptrace.New(context.Background(), c)
 }
+
+func otlpMetricExporter() (sdkmetric.Exporter, error) {
+	set := os.Getenv("OTEL_METRICS_EXPORTER") == "otlp" || os.Getenv("OTEL_EXPORTER_OTLP_ENDPOINT") != "" || os.Getenv("OTEL_EXPORTER_OTLP_METRICS_ENDPOINT") != ""
+	if !set {
+		return nil, nil
+	}
+
+	proto := os.Getenv("OTEL_EXPORTER_OTLP_METRICS_PROTOCOL")
+	if proto == "" {
+		proto = os.Getenv("OTEL_EXPORTER_OTLP_PROTOCOL")
+	}
+	if proto == "" {
+		proto = "grpc"
+	}
+
+	switch proto {
+	case "grpc":
+		return otlpmetricgrpc.New(context.Background(),
+			otlpmetricgrpc.WithTemporalitySelector(deltaTemporality),
+		)
+	case "http/protobuf":
+		return otlpmetrichttp.New(context.Background(),
+			otlpmetrichttp.WithTemporalitySelector(deltaTemporality),
+		)
+	// case "http/json": // unsupported by library
+	default:
+		return nil, errors.Errorf("unsupported otlp protocol %v", proto)
+	}
+}
+
+func deltaTemporality(_ sdkmetric.InstrumentKind) metricdata.Temporality {
+	return metricdata.DeltaTemporality
+}

vendor/github.com/moby/buildkit/util/tracing/otlptracegrpc/client.go

@@ -70,9 +70,10 @@ func (c *client) UploadTraces(ctx context.Context, protoSpans []*tracepb.Resourc
 	}
 
 	ctx, cancel := c.connection.ContextWithStop(ctx)
-	defer cancel()
-	ctx, tCancel := context.WithTimeout(ctx, 30*time.Second)
-	defer tCancel()
+	defer cancel(errors.WithStack(context.Canceled))
+	ctx, tCancel := context.WithCancelCause(ctx)
+	ctx, _ = context.WithTimeoutCause(ctx, 30*time.Second, errors.WithStack(context.DeadlineExceeded))
+	defer tCancel(errors.WithStack(context.Canceled))
 
 	ctx = c.connection.ContextWithMetadata(ctx)
 	err := func() error {

vendor/github.com/moby/buildkit/util/tracing/otlptracegrpc/connection.go

@@ -22,6 +22,7 @@ import (
 	"time"
 	"unsafe"
 
+	"github.com/pkg/errors"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/metadata"
 )
@@ -185,7 +186,7 @@ func (c *Connection) Shutdown(ctx context.Context) error {
 	select {
 	case <-c.backgroundConnectionDoneCh:
 	case <-ctx.Done():
-		return ctx.Err()
+		return context.Cause(ctx)
 	}
 
 	c.mu.Lock()
@@ -200,17 +201,17 @@ func (c *Connection) Shutdown(ctx context.Context) error {
 	return nil
 }
 
-func (c *Connection) ContextWithStop(ctx context.Context) (context.Context, context.CancelFunc) {
+func (c *Connection) ContextWithStop(ctx context.Context) (context.Context, context.CancelCauseFunc) {
 	// Unify the parent context Done signal with the Connection's
 	// stop channel.
-	ctx, cancel := context.WithCancel(ctx)
-	go func(ctx context.Context, cancel context.CancelFunc) {
+	ctx, cancel := context.WithCancelCause(ctx)
+	go func(ctx context.Context, cancel context.CancelCauseFunc) {
 		select {
 		case <-ctx.Done():
 			// Nothing to do, either cancelled or deadline
 			// happened.
 		case <-c.stopCh:
-			cancel()
+			cancel(errors.WithStack(context.Canceled))
 		}
 	}(ctx, cancel)
 	return ctx, cancel