deps: update buildkit, vendor changes

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

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 {