vendor: update buildkit to 2f99651

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

vendor/go.opentelemetry.io/otel/internal/global/internal_logging.go

@@ -0,0 +1,63 @@
+// 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 global // import "go.opentelemetry.io/otel/internal/global"
+
+import (
+	"log"
+	"os"
+	"sync"
+
+	"github.com/go-logr/logr"
+	"github.com/go-logr/stdr"
+)
+
+// globalLogger is the logging interface used within the otel api and sdk provide deatails of the internals.
+//
+// The default logger uses stdr which is backed by the standard `log.Logger`
+// interface. This logger will only show messages at the Error Level.
+var globalLogger logr.Logger = stdr.New(log.New(os.Stderr, "", log.LstdFlags|log.Lshortfile))
+var globalLoggerLock = &sync.RWMutex{}
+
+// SetLogger overrides the globalLogger with l.
+//
+// To see Info messages use a logger with `l.V(1).Enabled() == true`
+// To see Debug messages use a logger with `l.V(5).Enabled() == true`
+func SetLogger(l logr.Logger) {
+	globalLoggerLock.Lock()
+	defer globalLoggerLock.Unlock()
+	globalLogger = l
+}
+
+// Info prints messages about the general state of the API or SDK.
+// This should usually be less then 5 messages a minute
+func Info(msg string, keysAndValues ...interface{}) {
+	globalLoggerLock.RLock()
+	defer globalLoggerLock.RUnlock()
+	globalLogger.V(1).Info(msg, keysAndValues...)
+}
+
+// Error prints messages about exceptional states of the API or SDK.
+func Error(err error, msg string, keysAndValues ...interface{}) {
+	globalLoggerLock.RLock()
+	defer globalLoggerLock.RUnlock()
+	globalLogger.Error(err, msg, keysAndValues...)
+}
+
+// Debug prints messages about all internal changes in the API or SDK.
+func Debug(msg string, keysAndValues ...interface{}) {
+	globalLoggerLock.RLock()
+	defer globalLoggerLock.RUnlock()
+	globalLogger.V(5).Info(msg, keysAndValues...)
+}

vendor/go.opentelemetry.io/otel/internal/metric/global/meter.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package global
+package global // import "go.opentelemetry.io/otel/internal/metric/global"
 
 import (
 	"context"
@@ -24,6 +24,7 @@ import (
 	"go.opentelemetry.io/otel/internal/metric/registry"
 	"go.opentelemetry.io/otel/metric"
 	"go.opentelemetry.io/otel/metric/number"
+	"go.opentelemetry.io/otel/metric/sdkapi"
 )
 
 // This file contains the forwarding implementation of MeterProvider used as
@@ -40,10 +41,6 @@ import (
 // in the MeterProvider and Meters ensure that each instrument has a delegate
 // before the global provider is set.
 //
-// Bound instrument operations are implemented by delegating to the
-// instrument after it is registered, with a sync.Once initializer to
-// protect against races with Release().
-//
 // Metric uniqueness checking is implemented by calling the exported
 // methods of the api/metric/registry package.
 
@@ -73,56 +70,46 @@ type meterImpl struct {
 }
 
 type meterEntry struct {
-	unique metric.MeterImpl
+	unique sdkapi.MeterImpl
 	impl   meterImpl
 }
 
 type instrument struct {
-	descriptor metric.Descriptor
+	descriptor sdkapi.Descriptor
 }
 
 type syncImpl struct {
-	delegate unsafe.Pointer // (*metric.SyncImpl)
+	delegate unsafe.Pointer // (*sdkapi.SyncImpl)
 
 	instrument
 }
 
 type asyncImpl struct {
-	delegate unsafe.Pointer // (*metric.AsyncImpl)
+	delegate unsafe.Pointer // (*sdkapi.AsyncImpl)
 
 	instrument
 
-	runner metric.AsyncRunner
+	runner sdkapi.AsyncRunner
 }
 
 // SyncImpler is implemented by all of the sync metric
 // instruments.
 type SyncImpler interface {
-	SyncImpl() metric.SyncImpl
+	SyncImpl() sdkapi.SyncImpl
 }
 
 // AsyncImpler is implemented by all of the async
 // metric instruments.
 type AsyncImpler interface {
-	AsyncImpl() metric.AsyncImpl
-}
-
-type syncHandle struct {
-	delegate unsafe.Pointer // (*metric.BoundInstrumentImpl)
-
-	inst   *syncImpl
-	labels []attribute.KeyValue
-
-	initialize sync.Once
+	AsyncImpl() sdkapi.AsyncImpl
 }
 
 var _ metric.MeterProvider = &meterProvider{}
-var _ metric.MeterImpl = &meterImpl{}
-var _ metric.InstrumentImpl = &syncImpl{}
-var _ metric.BoundSyncImpl = &syncHandle{}
-var _ metric.AsyncImpl = &asyncImpl{}
+var _ sdkapi.MeterImpl = &meterImpl{}
+var _ sdkapi.InstrumentImpl = &syncImpl{}
+var _ sdkapi.AsyncImpl = &asyncImpl{}
 
-func (inst *instrument) Descriptor() metric.Descriptor {
+func (inst *instrument) Descriptor() sdkapi.Descriptor {
 	return inst.descriptor
 }
 
@@ -179,7 +166,7 @@ func (m *meterImpl) setDelegate(key meterKey, provider metric.MeterProvider) {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
-	d := new(metric.MeterImpl)
+	d := new(sdkapi.MeterImpl)
 	*d = provider.Meter(
 		key.InstrumentationName,
 		metric.WithInstrumentationVersion(key.InstrumentationVersion),
@@ -197,11 +184,11 @@ func (m *meterImpl) setDelegate(key meterKey, provider metric.MeterProvider) {
 	m.asyncInsts = nil
 }
 
-func (m *meterImpl) NewSyncInstrument(desc metric.Descriptor) (metric.SyncImpl, error) {
+func (m *meterImpl) NewSyncInstrument(desc sdkapi.Descriptor) (sdkapi.SyncImpl, error) {
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
-	if meterPtr := (*metric.MeterImpl)(atomic.LoadPointer(&m.delegate)); meterPtr != nil {
+	if meterPtr := (*sdkapi.MeterImpl)(atomic.LoadPointer(&m.delegate)); meterPtr != nil {
 		return (*meterPtr).NewSyncInstrument(desc)
 	}
 
@@ -216,8 +203,8 @@ func (m *meterImpl) NewSyncInstrument(desc metric.Descriptor) (metric.SyncImpl,
 
 // Synchronous delegation
 
-func (inst *syncImpl) setDelegate(d metric.MeterImpl) {
-	implPtr := new(metric.SyncImpl)
+func (inst *syncImpl) setDelegate(d sdkapi.MeterImpl) {
+	implPtr := new(sdkapi.SyncImpl)
 
 	var err error
 	*implPtr, err = d.NewSyncInstrument(inst.descriptor)
@@ -234,45 +221,23 @@ func (inst *syncImpl) setDelegate(d metric.MeterImpl) {
 }
 
 func (inst *syncImpl) Implementation() interface{} {
-	if implPtr := (*metric.SyncImpl)(atomic.LoadPointer(&inst.delegate)); implPtr != nil {
+	if implPtr := (*sdkapi.SyncImpl)(atomic.LoadPointer(&inst.delegate)); implPtr != nil {
 		return (*implPtr).Implementation()
 	}
 	return inst
 }
 
-func (inst *syncImpl) Bind(labels []attribute.KeyValue) metric.BoundSyncImpl {
-	if implPtr := (*metric.SyncImpl)(atomic.LoadPointer(&inst.delegate)); implPtr != nil {
-		return (*implPtr).Bind(labels)
-	}
-	return &syncHandle{
-		inst:   inst,
-		labels: labels,
-	}
-}
-
-func (bound *syncHandle) Unbind() {
-	bound.initialize.Do(func() {})
-
-	implPtr := (*metric.BoundSyncImpl)(atomic.LoadPointer(&bound.delegate))
-
-	if implPtr == nil {
-		return
-	}
-
-	(*implPtr).Unbind()
-}
-
 // Async delegation
 
 func (m *meterImpl) NewAsyncInstrument(
-	desc metric.Descriptor,
-	runner metric.AsyncRunner,
-) (metric.AsyncImpl, error) {
+	desc sdkapi.Descriptor,
+	runner sdkapi.AsyncRunner,
+) (sdkapi.AsyncImpl, error) {
 
 	m.lock.Lock()
 	defer m.lock.Unlock()
 
-	if meterPtr := (*metric.MeterImpl)(atomic.LoadPointer(&m.delegate)); meterPtr != nil {
+	if meterPtr := (*sdkapi.MeterImpl)(atomic.LoadPointer(&m.delegate)); meterPtr != nil {
 		return (*meterPtr).NewAsyncInstrument(desc, runner)
 	}
 
@@ -287,14 +252,14 @@ func (m *meterImpl) NewAsyncInstrument(
 }
 
 func (obs *asyncImpl) Implementation() interface{} {
-	if implPtr := (*metric.AsyncImpl)(atomic.LoadPointer(&obs.delegate)); implPtr != nil {
+	if implPtr := (*sdkapi.AsyncImpl)(atomic.LoadPointer(&obs.delegate)); implPtr != nil {
 		return (*implPtr).Implementation()
 	}
 	return obs
 }
 
-func (obs *asyncImpl) setDelegate(d metric.MeterImpl) {
-	implPtr := new(metric.AsyncImpl)
+func (obs *asyncImpl) setDelegate(d sdkapi.MeterImpl) {
+	implPtr := new(sdkapi.AsyncImpl)
 
 	var err error
 	*implPtr, err = d.NewAsyncInstrument(obs.descriptor, obs.runner)
@@ -312,49 +277,23 @@ func (obs *asyncImpl) setDelegate(d metric.MeterImpl) {
 
 // Metric updates
 
-func (m *meterImpl) RecordBatch(ctx context.Context, labels []attribute.KeyValue, measurements ...metric.Measurement) {
-	if delegatePtr := (*metric.MeterImpl)(atomic.LoadPointer(&m.delegate)); delegatePtr != nil {
+func (m *meterImpl) RecordBatch(ctx context.Context, labels []attribute.KeyValue, measurements ...sdkapi.Measurement) {
+	if delegatePtr := (*sdkapi.MeterImpl)(atomic.LoadPointer(&m.delegate)); delegatePtr != nil {
 		(*delegatePtr).RecordBatch(ctx, labels, measurements...)
 	}
 }
 
 func (inst *syncImpl) RecordOne(ctx context.Context, number number.Number, labels []attribute.KeyValue) {
-	if instPtr := (*metric.SyncImpl)(atomic.LoadPointer(&inst.delegate)); instPtr != nil {
+	if instPtr := (*sdkapi.SyncImpl)(atomic.LoadPointer(&inst.delegate)); instPtr != nil {
 		(*instPtr).RecordOne(ctx, number, labels)
 	}
 }
 
-// Bound instrument initialization
-
-func (bound *syncHandle) RecordOne(ctx context.Context, number number.Number) {
-	instPtr := (*metric.SyncImpl)(atomic.LoadPointer(&bound.inst.delegate))
-	if instPtr == nil {
-		return
-	}
-	var implPtr *metric.BoundSyncImpl
-	bound.initialize.Do(func() {
-		implPtr = new(metric.BoundSyncImpl)
-		*implPtr = (*instPtr).Bind(bound.labels)
-		atomic.StorePointer(&bound.delegate, unsafe.Pointer(implPtr))
-	})
-	if implPtr == nil {
-		implPtr = (*metric.BoundSyncImpl)(atomic.LoadPointer(&bound.delegate))
-	}
-	// This may still be nil if instrument was created and bound
-	// without a delegate, then the instrument was set to have a
-	// delegate and unbound.
-	if implPtr == nil {
-		return
-	}
-	(*implPtr).RecordOne(ctx, number)
-}
-
 func AtomicFieldOffsets() map[string]uintptr {
 	return map[string]uintptr{
 		"meterProvider.delegate": unsafe.Offsetof(meterProvider{}.delegate),
 		"meterImpl.delegate":     unsafe.Offsetof(meterImpl{}.delegate),
 		"syncImpl.delegate":      unsafe.Offsetof(syncImpl{}.delegate),
 		"asyncImpl.delegate":     unsafe.Offsetof(asyncImpl{}.delegate),
-		"syncHandle.delegate":    unsafe.Offsetof(syncHandle{}.delegate),
 	}
 }

vendor/go.opentelemetry.io/otel/internal/metric/global/metric.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package global
+package global // import "go.opentelemetry.io/otel/internal/metric/global"
 
 import (
 	"sync"

vendor/go.opentelemetry.io/otel/internal/metric/registry/registry.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package registry // import "go.opentelemetry.io/otel/metric/registry"
+package registry // import "go.opentelemetry.io/otel/internal/metric/registry"
 
 import (
 	"context"
@@ -20,18 +20,18 @@ import (
 	"sync"
 
 	"go.opentelemetry.io/otel/attribute"
-	"go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/metric/sdkapi"
 )
 
 // UniqueInstrumentMeterImpl implements the metric.MeterImpl interface, adding
 // uniqueness checking for instrument descriptors.
 type UniqueInstrumentMeterImpl struct {
 	lock  sync.Mutex
-	impl  metric.MeterImpl
-	state map[string]metric.InstrumentImpl
+	impl  sdkapi.MeterImpl
+	state map[string]sdkapi.InstrumentImpl
 }
 
-var _ metric.MeterImpl = (*UniqueInstrumentMeterImpl)(nil)
+var _ sdkapi.MeterImpl = (*UniqueInstrumentMeterImpl)(nil)
 
 // ErrMetricKindMismatch is the standard error for mismatched metric
 // instrument definitions.
@@ -40,27 +40,27 @@ var ErrMetricKindMismatch = fmt.Errorf(
 
 // NewUniqueInstrumentMeterImpl returns a wrapped metric.MeterImpl
 // with the addition of instrument name uniqueness checking.
-func NewUniqueInstrumentMeterImpl(impl metric.MeterImpl) *UniqueInstrumentMeterImpl {
+func NewUniqueInstrumentMeterImpl(impl sdkapi.MeterImpl) *UniqueInstrumentMeterImpl {
 	return &UniqueInstrumentMeterImpl{
 		impl:  impl,
-		state: map[string]metric.InstrumentImpl{},
+		state: map[string]sdkapi.InstrumentImpl{},
 	}
 }
 
 // MeterImpl gives the caller access to the underlying MeterImpl
 // used by this UniqueInstrumentMeterImpl.
-func (u *UniqueInstrumentMeterImpl) MeterImpl() metric.MeterImpl {
+func (u *UniqueInstrumentMeterImpl) MeterImpl() sdkapi.MeterImpl {
 	return u.impl
 }
 
-// RecordBatch implements metric.MeterImpl.
-func (u *UniqueInstrumentMeterImpl) RecordBatch(ctx context.Context, labels []attribute.KeyValue, ms ...metric.Measurement) {
+// RecordBatch implements sdkapi.MeterImpl.
+func (u *UniqueInstrumentMeterImpl) RecordBatch(ctx context.Context, labels []attribute.KeyValue, ms ...sdkapi.Measurement) {
 	u.impl.RecordBatch(ctx, labels, ms...)
 }
 
 // NewMetricKindMismatchError formats an error that describes a
 // mismatched metric instrument definition.
-func NewMetricKindMismatchError(desc metric.Descriptor) error {
+func NewMetricKindMismatchError(desc sdkapi.Descriptor) error {
 	return fmt.Errorf("metric %s registered as %s %s: %w",
 		desc.Name(),
 		desc.NumberKind(),
@@ -68,9 +68,9 @@ func NewMetricKindMismatchError(desc metric.Descriptor) error {
 		ErrMetricKindMismatch)
 }
 
-// Compatible determines whether two metric.Descriptors are considered
+// Compatible determines whether two sdkapi.Descriptors are considered
 // the same for the purpose of uniqueness checking.
-func Compatible(candidate, existing metric.Descriptor) bool {
+func Compatible(candidate, existing sdkapi.Descriptor) bool {
 	return candidate.InstrumentKind() == existing.InstrumentKind() &&
 		candidate.NumberKind() == existing.NumberKind()
 }
@@ -80,7 +80,7 @@ func Compatible(candidate, existing metric.Descriptor) bool {
 // `descriptor` argument.  If there is an existing compatible
 // registration, this returns the already-registered instrument.  If
 // there is no conflict and no prior registration, returns (nil, nil).
-func (u *UniqueInstrumentMeterImpl) checkUniqueness(descriptor metric.Descriptor) (metric.InstrumentImpl, error) {
+func (u *UniqueInstrumentMeterImpl) checkUniqueness(descriptor sdkapi.Descriptor) (sdkapi.InstrumentImpl, error) {
 	impl, ok := u.state[descriptor.Name()]
 	if !ok {
 		return nil, nil
@@ -93,8 +93,8 @@ func (u *UniqueInstrumentMeterImpl) checkUniqueness(descriptor metric.Descriptor
 	return impl, nil
 }
 
-// NewSyncInstrument implements metric.MeterImpl.
-func (u *UniqueInstrumentMeterImpl) NewSyncInstrument(descriptor metric.Descriptor) (metric.SyncImpl, error) {
+// NewSyncInstrument implements sdkapi.MeterImpl.
+func (u *UniqueInstrumentMeterImpl) NewSyncInstrument(descriptor sdkapi.Descriptor) (sdkapi.SyncImpl, error) {
 	u.lock.Lock()
 	defer u.lock.Unlock()
 
@@ -103,7 +103,7 @@ func (u *UniqueInstrumentMeterImpl) NewSyncInstrument(descriptor metric.Descript
 	if err != nil {
 		return nil, err
 	} else if impl != nil {
-		return impl.(metric.SyncImpl), nil
+		return impl.(sdkapi.SyncImpl), nil
 	}
 
 	syncInst, err := u.impl.NewSyncInstrument(descriptor)
@@ -114,11 +114,11 @@ func (u *UniqueInstrumentMeterImpl) NewSyncInstrument(descriptor metric.Descript
 	return syncInst, nil
 }
 
-// NewAsyncInstrument implements metric.MeterImpl.
+// NewAsyncInstrument implements sdkapi.MeterImpl.
 func (u *UniqueInstrumentMeterImpl) NewAsyncInstrument(
-	descriptor metric.Descriptor,
-	runner metric.AsyncRunner,
-) (metric.AsyncImpl, error) {
+	descriptor sdkapi.Descriptor,
+	runner sdkapi.AsyncRunner,
+) (sdkapi.AsyncImpl, error) {
 	u.lock.Lock()
 	defer u.lock.Unlock()
 
@@ -127,7 +127,7 @@ func (u *UniqueInstrumentMeterImpl) NewAsyncInstrument(
 	if err != nil {
 		return nil, err
 	} else if impl != nil {
-		return impl.(metric.AsyncImpl), nil
+		return impl.(sdkapi.AsyncImpl), nil
 	}
 
 	asyncInst, err := u.impl.NewAsyncInstrument(descriptor, runner)