chore: update dependencies

vendor/go.opentelemetry.io/otel/CHANGELOG.md

@@ -8,9 +8,51 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 ## [Unreleased]
 
+## [1.3.0] - 2021-12-10
+
+### ⚠️ Notice ⚠️
+
+We have updated the project minimum supported Go version to 1.16
+
+### Added
+
+- Added an internal Logger.
+  This can be used by the SDK and API to provide users with feedback of the internal state.
+  To enable verbose logs configure the logger which will print V(1) logs. For debugging information configure to print V(5) logs. (#2343)
+- Add the `WithRetry` `Option` and the `RetryConfig` type to the `go.opentelemetry.io/otel/exporter/otel/otlpmetric/otlpmetrichttp` package to specify retry behavior consistently. (#2425)
+- Add `SpanStatusFromHTTPStatusCodeAndSpanKind` to all `semconv` packages to return a span status code similar to `SpanStatusFromHTTPStatusCode`, but exclude `4XX` HTTP errors as span errors if the span is of server kind. (#2296)
+
+### Changed
+
+- The `"go.opentelemetry.io/otel/exporter/otel/otlptrace/otlptracegrpc".Client` now uses the underlying gRPC `ClientConn` to handle name resolution, TCP connection establishment (with retries and backoff) and TLS handshakes, and handling errors on established connections by re-resolving the name and reconnecting. (#2329)
+- The `"go.opentelemetry.io/otel/exporter/otel/otlpmetric/otlpmetricgrpc".Client` now uses the underlying gRPC `ClientConn` to handle name resolution, TCP connection establishment (with retries and backoff) and TLS handshakes, and handling errors on established connections by re-resolving the name and reconnecting. (#2425)
+- The `"go.opentelemetry.io/otel/exporter/otel/otlpmetric/otlpmetricgrpc".RetrySettings` type is renamed to `RetryConfig`. (#2425)
+- The `go.opentelemetry.io/otel/exporter/otel/*` gRPC exporters now default to using the host's root CA set if none are provided by the user and `WithInsecure` is not specified. (#2432)
+- Change `resource.Default` to be evaluated the first time it is called, rather than on import. This allows the caller the option to update `OTEL_RESOURCE_ATTRIBUTES` first, such as with `os.Setenv`. (#2371)
+
+### Fixed
+
+- The `go.opentelemetry.io/otel/exporter/otel/*` exporters are updated to handle per-signal and universal endpoints according to the OpenTelemetry specification.
+  Any per-signal endpoint set via an `OTEL_EXPORTER_OTLP_<signal>_ENDPOINT` environment variable is now used without modification of the path.
+  When `OTEL_EXPORTER_OTLP_ENDPOINT` is set, if it contains a path, that path is used as a base path which per-signal paths are appended to. (#2433)
+- Basic metric controller updated to use sync.Map to avoid blocking calls (#2381)
+- The `go.opentelemetry.io/otel/exporter/jaeger` correctly sets the `otel.status_code` value to be a string of `ERROR` or `OK` instead of an integer code. (#2439, #2440)
+
+### Deprecated
+
+- Deprecated the `"go.opentelemetry.io/otel/exporter/otel/otlpmetric/otlpmetrichttp".WithMaxAttempts` `Option`, use the new `WithRetry` `Option` instead. (#2425)
+- Deprecated the `"go.opentelemetry.io/otel/exporter/otel/otlpmetric/otlpmetrichttp".WithBackoff` `Option`, use the new `WithRetry` `Option` instead. (#2425)
+
+### Removed
+
+- Remove the metric Processor's ability to convert cumulative to delta aggregation temporality. (#2350)
+- Remove the metric Bound Instruments interface and implementations. (#2399)
+- Remove the metric MinMaxSumCount kind aggregation and the corresponding OTLP export path. (#2423)
+- Metric SDK removes the "exact" aggregator for histogram instruments, as it performed a non-standard aggregation for OTLP export (creating repeated Gauge points) and worked its way into a number of confusing examples. (#2348)
+
 ## [1.2.0] - 2021-11-12
 
-## Changed
+### Changed
 
 - Metric SDK `export.ExportKind`, `export.ExportKindSelector` types have been renamed to `aggregation.Temporality` and `aggregation.TemporalitySelector` respectively to keep in line with current specification and protocol along with built-in selectors (e.g., `aggregation.CumulativeTemporalitySelector`, ...). (#2274)
 - The Metric `Exporter` interface now requires a `TemporalitySelector` method instead of an `ExportKindSelector`. (#2274)
@@ -24,7 +66,7 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 
 - Add the `"go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc".WithGRPCConn` option so the exporter can reuse an existing gRPC connection. (#2002)
 - Added a new `schema` module to help parse Schema Files in OTEP 0152 format. (#2267)
-- Added a new `MapCarrier` to the `go.opentelemetry.io/otel/propagation` package to hold propagated coss-cutting concerns as a `map[string]string` held in memory. (#2334)
+- Added a new `MapCarrier` to the `go.opentelemetry.io/otel/propagation` package to hold propagated cross-cutting concerns as a `map[string]string` held in memory. (#2334)
 
 ## [1.1.0] - 2021-10-27
 
@@ -1597,7 +1639,8 @@ It contains api and sdk for trace and meter.
 - CircleCI build CI manifest files.
 - CODEOWNERS file to track owners of this project.
 
-[Unreleased]: https://github.com/open-telemetry/opentelemetry-go/compare/v1.2.0...HEAD
+[Unreleased]: https://github.com/open-telemetry/opentelemetry-go/compare/v1.3.0...HEAD
+[1.3.0]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.3.0
 [1.2.0]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.2.0
 [1.1.0]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.1.0
 [1.0.1]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.0.1

vendor/go.opentelemetry.io/otel/CODEOWNERS

@@ -14,4 +14,4 @@
 
 * @jmacd @MrAlias @Aneurysm9 @evantorrie @XSAM @dashpole @paivagustavo @MadVikingGod @pellared
 
-CODEOWNERS @MrAlias @Aneurysm9
+CODEOWNERS @MrAlias @Aneurysm9 @MadVikingGod

vendor/go.opentelemetry.io/otel/CONTRIBUTING.md

@@ -481,11 +481,11 @@ Approvers:
 - [Sam Xie](https://github.com/XSAM)
 - [David Ashpole](https://github.com/dashpole), Google
 - [Gustavo Silva Paiva](https://github.com/paivagustavo), LightStep
-- [Aaron Clawson](https://github.com/MadVikingGod)
 - [Robert Pająk](https://github.com/pellared), Splunk
 
 Maintainers:
 
+- [Aaron Clawson](https://github.com/MadVikingGod), LightStep
 - [Anthony Mirabella](https://github.com/Aneurysm9), AWS
 - [Tyler Yahn](https://github.com/MrAlias), Splunk
 

vendor/go.opentelemetry.io/otel/README.md

@@ -30,25 +30,27 @@ Project versioning information and stability guarantees can be found in the
 
 ### Compatibility
 
+OpenTelemetry-Go attempts to track the current supported versions of the
+[Go language](https://golang.org/doc/devel/release#policy). The release
+schedule after a new minor version of go is as follows:
+
+- The first release or one month, which ever is sooner, will add build steps for the new go version.
+- The first release after three months will remove support for the oldest go version.
+
 This project is tested on the following systems.
 
 | OS      | Go Version | Architecture |
 | ------- | ---------- | ------------ |
 | Ubuntu  | 1.17       | amd64        |
 | Ubuntu  | 1.16       | amd64        |
-| Ubuntu  | 1.15       | amd64        |
 | Ubuntu  | 1.17       | 386          |
 | Ubuntu  | 1.16       | 386          |
-| Ubuntu  | 1.15       | 386          |
 | MacOS   | 1.17       | amd64        |
 | MacOS   | 1.16       | amd64        |
-| MacOS   | 1.15       | amd64        |
 | Windows | 1.17       | amd64        |
 | Windows | 1.16       | amd64        |
-| Windows | 1.15       | amd64        |
 | Windows | 1.17       | 386          |
 | Windows | 1.16       | 386          |
-| Windows | 1.15       | 386          |
 
 While this project should work for other systems, no compatibility guarantees
 are made for those systems currently.

vendor/go.opentelemetry.io/otel/exporters/stdout/stdoutmetric/metric.go

@@ -37,8 +37,6 @@ var _ exportmetric.Exporter = &metricExporter{}
 
 type line struct {
 	Name      string      `json:"Name"`
-	Min       interface{} `json:"Min,omitempty"`
-	Max       interface{} `json:"Max,omitempty"`
 	Sum       interface{} `json:"Sum,omitempty"`
 	Count     interface{} `json:"Count,omitempty"`
 	LastValue interface{} `json:"Last,omitempty"`
@@ -83,26 +81,6 @@ func (e *metricExporter) Export(_ context.Context, res *resource.Resource, reade
 					return err
 				}
 				expose.Sum = value.AsInterface(kind)
-			}
-
-			if mmsc, ok := agg.(aggregation.MinMaxSumCount); ok {
-				count, err := mmsc.Count()
-				if err != nil {
-					return err
-				}
-				expose.Count = count
-
-				max, err := mmsc.Max()
-				if err != nil {
-					return err
-				}
-				expose.Max = max.AsInterface(kind)
-
-				min, err := mmsc.Min()
-				if err != nil {
-					return err
-				}
-				expose.Min = min.AsInterface(kind)
 			} else if lv, ok := agg.(aggregation.LastValue); ok {
 				value, timestamp, err := lv.LastValue()
 				if err != nil {

vendor/go.opentelemetry.io/otel/handler.go

@@ -18,7 +18,6 @@ import (
 	"log"
 	"os"
 	"sync"
-	"sync/atomic"
 )
 
 var (
@@ -28,44 +27,45 @@ var (
 	// `Handle` and will be delegated to the registered ErrorHandler.
 	globalErrorHandler = defaultErrorHandler()
 
-	// delegateErrorHandlerOnce ensures that a user provided ErrorHandler is
-	// only ever registered once.
-	delegateErrorHandlerOnce sync.Once
-
 	// Compile-time check that delegator implements ErrorHandler.
 	_ ErrorHandler = (*delegator)(nil)
+	// Compile-time check that errLogger implements ErrorHandler.
+	_ ErrorHandler = (*errLogger)(nil)
 )
 
-type holder struct {
-	eh ErrorHandler
-}
-
-func defaultErrorHandler() *atomic.Value {
-	v := &atomic.Value{}
-	v.Store(holder{eh: &delegator{l: log.New(os.Stderr, "", log.LstdFlags)}})
-	return v
-}
-
-// delegator logs errors if no delegate is set, otherwise they are delegated.
 type delegator struct {
-	delegate atomic.Value
+	lock *sync.RWMutex
+	eh   ErrorHandler
+}
 
-	l *log.Logger
+func (d *delegator) Handle(err error) {
+	d.lock.RLock()
+	defer d.lock.RUnlock()
+	d.eh.Handle(err)
 }
 
 // setDelegate sets the ErrorHandler delegate.
-func (h *delegator) setDelegate(d ErrorHandler) {
-	// It is critical this is guarded with delegateErrorHandlerOnce, if it is
-	// called again with a different concrete type it will panic.
-	h.delegate.Store(d)
+func (d *delegator) setDelegate(eh ErrorHandler) {
+	d.lock.Lock()
+	defer d.lock.Unlock()
+	d.eh = eh
+}
+
+func defaultErrorHandler() *delegator {
+	return &delegator{
+		lock: &sync.RWMutex{},
+		eh:   &errLogger{l: log.New(os.Stderr, "", log.LstdFlags)},
+	}
+
+}
+
+// errLogger logs errors if no delegate is set, otherwise they are delegated.
+type errLogger struct {
+	l *log.Logger
 }
 
 // Handle logs err if no delegate is set, otherwise it is delegated.
-func (h *delegator) Handle(err error) {
-	if d := h.delegate.Load(); d != nil {
-		d.(ErrorHandler).Handle(err)
-		return
-	}
+func (h *errLogger) Handle(err error) {
 	h.l.Print(err)
 }
 
@@ -79,7 +79,7 @@ func (h *delegator) Handle(err error) {
 // Subsequent calls to SetErrorHandler after the first will not forward errors
 // to the new ErrorHandler for prior returned instances.
 func GetErrorHandler() ErrorHandler {
-	return globalErrorHandler.Load().(holder).eh
+	return globalErrorHandler
 }
 
 // SetErrorHandler sets the global ErrorHandler to h.
@@ -89,16 +89,7 @@ func GetErrorHandler() ErrorHandler {
 // ErrorHandler. Subsequent calls will set the global ErrorHandler, but not
 // delegate errors to h.
 func SetErrorHandler(h ErrorHandler) {
-	delegateErrorHandlerOnce.Do(func() {
-		current := GetErrorHandler()
-		if current == h {
-			return
-		}
-		if internalHandler, ok := current.(*delegator); ok {
-			internalHandler.setDelegate(h)
-		}
-	})
-	globalErrorHandler.Store(holder{eh: h})
+	globalErrorHandler.setDelegate(h)
 }
 
 // Handle is a convenience function for ErrorHandler().Handle(err)

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

@@ -41,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.
 
@@ -108,19 +104,9 @@ type AsyncImpler interface {
 	AsyncImpl() sdkapi.AsyncImpl
 }
 
-type syncHandle struct {
-	delegate unsafe.Pointer // (*sdkapi.BoundInstrumentImpl)
-
-	inst   *syncImpl
-	labels []attribute.KeyValue
-
-	initialize sync.Once
-}
-
 var _ metric.MeterProvider = &meterProvider{}
 var _ sdkapi.MeterImpl = &meterImpl{}
 var _ sdkapi.InstrumentImpl = &syncImpl{}
-var _ sdkapi.BoundSyncImpl = &syncHandle{}
 var _ sdkapi.AsyncImpl = &asyncImpl{}
 
 func (inst *instrument) Descriptor() sdkapi.Descriptor {
@@ -241,28 +227,6 @@ func (inst *syncImpl) Implementation() interface{} {
 	return inst
 }
 
-func (inst *syncImpl) Bind(labels []attribute.KeyValue) sdkapi.BoundSyncImpl {
-	if implPtr := (*sdkapi.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 := (*sdkapi.BoundSyncImpl)(atomic.LoadPointer(&bound.delegate))
-
-	if implPtr == nil {
-		return
-	}
-
-	(*implPtr).Unbind()
-}
-
 // Async delegation
 
 func (m *meterImpl) NewAsyncInstrument(
@@ -325,37 +289,11 @@ func (inst *syncImpl) RecordOne(ctx context.Context, number number.Number, label
 	}
 }
 
-// Bound instrument initialization
-
-func (bound *syncHandle) RecordOne(ctx context.Context, number number.Number) {
-	instPtr := (*sdkapi.SyncImpl)(atomic.LoadPointer(&bound.inst.delegate))
-	if instPtr == nil {
-		return
-	}
-	var implPtr *sdkapi.BoundSyncImpl
-	bound.initialize.Do(func() {
-		implPtr = new(sdkapi.BoundSyncImpl)
-		*implPtr = (*instPtr).Bind(bound.labels)
-		atomic.StorePointer(&bound.delegate, unsafe.Pointer(implPtr))
-	})
-	if implPtr == nil {
-		implPtr = (*sdkapi.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_logging.go

@@ -0,0 +1,26 @@
+// 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 otel // import "go.opentelemetry.io/otel"
+
+import (
+	"github.com/go-logr/logr"
+
+	"go.opentelemetry.io/otel/internal/global"
+)
+
+// SetLogger configures the logger used internally to opentelemetry.
+func SetLogger(logger logr.Logger) {
+	global.SetLogger(logger)
+}

vendor/go.opentelemetry.io/otel/metric/metric_instrument.go

@@ -260,11 +260,6 @@ type syncInstrument struct {
 	instrument sdkapi.SyncImpl
 }
 
-// syncBoundInstrument contains a BoundSyncImpl.
-type syncBoundInstrument struct {
-	boundInstrument sdkapi.BoundSyncImpl
-}
-
 // asyncInstrument contains a AsyncImpl.
 type asyncInstrument struct {
 	instrument sdkapi.AsyncImpl
@@ -280,10 +275,6 @@ func (s syncInstrument) SyncImpl() sdkapi.SyncImpl {
 	return s.instrument
 }
 
-func (s syncInstrument) bind(labels []attribute.KeyValue) syncBoundInstrument {
-	return newSyncBoundInstrument(s.instrument.Bind(labels))
-}
-
 func (s syncInstrument) float64Measurement(value float64) Measurement {
 	return sdkapi.NewMeasurement(s.instrument, number.NewFloat64Number(value))
 }
@@ -296,15 +287,6 @@ func (s syncInstrument) directRecord(ctx context.Context, number number.Number,
 	s.instrument.RecordOne(ctx, number, labels)
 }
 
-func (h syncBoundInstrument) directRecord(ctx context.Context, number number.Number) {
-	h.boundInstrument.RecordOne(ctx, number)
-}
-
-// Unbind calls SyncImpl.Unbind.
-func (h syncBoundInstrument) Unbind() {
-	h.boundInstrument.Unbind()
-}
-
 // checkNewAsync receives an AsyncImpl and potential
 // error, and returns the same types, checking for and ensuring that
 // the returned interface is not nil.
@@ -340,12 +322,6 @@ func checkNewSync(instrument sdkapi.SyncImpl, err error) (syncInstrument, error)
 	}, err
 }
 
-func newSyncBoundInstrument(boundInstrument sdkapi.BoundSyncImpl) syncBoundInstrument {
-	return syncBoundInstrument{
-		boundInstrument: boundInstrument,
-	}
-}
-
 // wrapInt64CounterInstrument converts a SyncImpl into Int64Counter.
 func wrapInt64CounterInstrument(syncInst sdkapi.SyncImpl, err error) (Int64Counter, error) {
 	common, err := checkNewSync(syncInst, err)
@@ -392,34 +368,6 @@ type Int64Counter struct {
 	syncInstrument
 }
 
-// BoundFloat64Counter is a bound instrument for Float64Counter.
-//
-// It inherits the Unbind function from syncBoundInstrument.
-type BoundFloat64Counter struct {
-	syncBoundInstrument
-}
-
-// BoundInt64Counter is a boundInstrument for Int64Counter.
-//
-// It inherits the Unbind function from syncBoundInstrument.
-type BoundInt64Counter struct {
-	syncBoundInstrument
-}
-
-// Bind creates a bound instrument for this counter. The labels are
-// associated with values recorded via subsequent calls to Record.
-func (c Float64Counter) Bind(labels ...attribute.KeyValue) (h BoundFloat64Counter) {
-	h.syncBoundInstrument = c.bind(labels)
-	return
-}
-
-// Bind creates a bound instrument for this counter. The labels are
-// associated with values recorded via subsequent calls to Record.
-func (c Int64Counter) Bind(labels ...attribute.KeyValue) (h BoundInt64Counter) {
-	h.syncBoundInstrument = c.bind(labels)
-	return
-}
-
 // Measurement creates a Measurement object to use with batch
 // recording.
 func (c Float64Counter) Measurement(value float64) Measurement {
@@ -444,18 +392,6 @@ func (c Int64Counter) Add(ctx context.Context, value int64, labels ...attribute.
 	c.directRecord(ctx, number.NewInt64Number(value), labels)
 }
 
-// Add adds the value to the counter's sum using the labels
-// previously bound to this counter via Bind()
-func (b BoundFloat64Counter) Add(ctx context.Context, value float64) {
-	b.directRecord(ctx, number.NewFloat64Number(value))
-}
-
-// Add adds the value to the counter's sum using the labels
-// previously bound to this counter via Bind()
-func (b BoundInt64Counter) Add(ctx context.Context, value int64) {
-	b.directRecord(ctx, number.NewInt64Number(value))
-}
-
 // Float64UpDownCounter is a metric instrument that sums floating
 // point values.
 type Float64UpDownCounter struct {
@@ -467,34 +403,6 @@ type Int64UpDownCounter struct {
 	syncInstrument
 }
 
-// BoundFloat64UpDownCounter is a bound instrument for Float64UpDownCounter.
-//
-// It inherits the Unbind function from syncBoundInstrument.
-type BoundFloat64UpDownCounter struct {
-	syncBoundInstrument
-}
-
-// BoundInt64UpDownCounter is a boundInstrument for Int64UpDownCounter.
-//
-// It inherits the Unbind function from syncBoundInstrument.
-type BoundInt64UpDownCounter struct {
-	syncBoundInstrument
-}
-
-// Bind creates a bound instrument for this counter. The labels are
-// associated with values recorded via subsequent calls to Record.
-func (c Float64UpDownCounter) Bind(labels ...attribute.KeyValue) (h BoundFloat64UpDownCounter) {
-	h.syncBoundInstrument = c.bind(labels)
-	return
-}
-
-// Bind creates a bound instrument for this counter. The labels are
-// associated with values recorded via subsequent calls to Record.
-func (c Int64UpDownCounter) Bind(labels ...attribute.KeyValue) (h BoundInt64UpDownCounter) {
-	h.syncBoundInstrument = c.bind(labels)
-	return
-}
-
 // Measurement creates a Measurement object to use with batch
 // recording.
 func (c Float64UpDownCounter) Measurement(value float64) Measurement {
@@ -519,18 +427,6 @@ func (c Int64UpDownCounter) Add(ctx context.Context, value int64, labels ...attr
 	c.directRecord(ctx, number.NewInt64Number(value), labels)
 }
 
-// Add adds the value to the counter's sum using the labels
-// previously bound to this counter via Bind()
-func (b BoundFloat64UpDownCounter) Add(ctx context.Context, value float64) {
-	b.directRecord(ctx, number.NewFloat64Number(value))
-}
-
-// Add adds the value to the counter's sum using the labels
-// previously bound to this counter via Bind()
-func (b BoundInt64UpDownCounter) Add(ctx context.Context, value int64) {
-	b.directRecord(ctx, number.NewInt64Number(value))
-}
-
 // Float64Histogram is a metric that records float64 values.
 type Float64Histogram struct {
 	syncInstrument
@@ -541,34 +437,6 @@ type Int64Histogram struct {
 	syncInstrument
 }
 
-// BoundFloat64Histogram is a bound instrument for Float64Histogram.
-//
-// It inherits the Unbind function from syncBoundInstrument.
-type BoundFloat64Histogram struct {
-	syncBoundInstrument
-}
-
-// BoundInt64Histogram is a bound instrument for Int64Histogram.
-//
-// It inherits the Unbind function from syncBoundInstrument.
-type BoundInt64Histogram struct {
-	syncBoundInstrument
-}
-
-// Bind creates a bound instrument for this Histogram. The labels are
-// associated with values recorded via subsequent calls to Record.
-func (c Float64Histogram) Bind(labels ...attribute.KeyValue) (h BoundFloat64Histogram) {
-	h.syncBoundInstrument = c.bind(labels)
-	return
-}
-
-// Bind creates a bound instrument for this Histogram. The labels are
-// associated with values recorded via subsequent calls to Record.
-func (c Int64Histogram) Bind(labels ...attribute.KeyValue) (h BoundInt64Histogram) {
-	h.syncBoundInstrument = c.bind(labels)
-	return
-}
-
 // Measurement creates a Measurement object to use with batch
 // recording.
 func (c Float64Histogram) Measurement(value float64) Measurement {
@@ -594,15 +462,3 @@ func (c Float64Histogram) Record(ctx context.Context, value float64, labels ...a
 func (c Int64Histogram) Record(ctx context.Context, value int64, labels ...attribute.KeyValue) {
 	c.directRecord(ctx, number.NewInt64Number(value), labels)
 }
-
-// Record adds a new value to the Histogram's distribution using the labels
-// previously bound to the Histogram via Bind().
-func (b BoundFloat64Histogram) Record(ctx context.Context, value float64) {
-	b.directRecord(ctx, number.NewFloat64Number(value))
-}
-
-// Record adds a new value to the Histogram's distribution using the labels
-// previously bound to the Histogram via Bind().
-func (b BoundInt64Histogram) Record(ctx context.Context, value int64) {
-	b.directRecord(ctx, number.NewInt64Number(value))
-}

vendor/go.opentelemetry.io/otel/metric/sdkapi/noop.go

@@ -22,12 +22,10 @@ import (
 )
 
 type noopInstrument struct{}
-type noopBoundInstrument struct{}
 type noopSyncInstrument struct{ noopInstrument }
 type noopAsyncInstrument struct{ noopInstrument }
 
 var _ SyncImpl = noopSyncInstrument{}
-var _ BoundSyncImpl = noopBoundInstrument{}
 var _ AsyncImpl = noopAsyncInstrument{}
 
 // NewNoopSyncInstrument returns a No-op implementation of the
@@ -50,15 +48,5 @@ func (noopInstrument) Descriptor() Descriptor {
 	return Descriptor{}
 }
 
-func (noopBoundInstrument) RecordOne(context.Context, number.Number) {
-}
-
-func (noopBoundInstrument) Unbind() {
-}
-
-func (noopSyncInstrument) Bind([]attribute.KeyValue) BoundSyncImpl {
-	return noopBoundInstrument{}
-}
-
 func (noopSyncInstrument) RecordOne(context.Context, number.Number, []attribute.KeyValue) {
 }

vendor/go.opentelemetry.io/otel/metric/sdkapi/sdkapi.go

@@ -58,26 +58,10 @@ type InstrumentImpl interface {
 type SyncImpl interface {
 	InstrumentImpl
 
-	// Bind creates an implementation-level bound instrument,
-	// binding a label set with this instrument implementation.
-	Bind(labels []attribute.KeyValue) BoundSyncImpl
-
 	// RecordOne captures a single synchronous metric event.
 	RecordOne(ctx context.Context, number number.Number, labels []attribute.KeyValue)
 }
 
-// BoundSyncImpl is the implementation-level interface to a
-// generic bound synchronous instrument
-type BoundSyncImpl interface {
-
-	// RecordOne captures a single synchronous metric event.
-	RecordOne(ctx context.Context, number number.Number)
-
-	// Unbind frees the resources associated with this bound instrument. It
-	// does not affect the metric this bound instrument was created through.
-	Unbind()
-}
-
 // AsyncImpl is an implementation-level interface to an
 // asynchronous instrument (e.g., Observer instruments).
 type AsyncImpl interface {

vendor/go.opentelemetry.io/otel/propagation/baggage.go

@@ -25,7 +25,7 @@ const baggageHeader = "baggage"
 // Baggage is a propagator that supports the W3C Baggage format.
 //
 // This propagates user-defined baggage associated with a trace. The complete
-// specification is defined at https://w3c.github.io/baggage/.
+// specification is defined at https://www.w3.org/TR/baggage/.
 type Baggage struct{}
 
 var _ TextMapPropagator = Baggage{}

vendor/go.opentelemetry.io/otel/propagation/doc.go

@@ -19,6 +19,6 @@ OpenTelemetry propagators are used to extract and inject context data from and
 into messages exchanged by applications. The propagator supported by this
 package is the W3C Trace Context encoding
 (https://www.w3.org/TR/trace-context/), and W3C Baggage
-(https://w3c.github.io/baggage/).
+(https://www.w3.org/TR/baggage/).
 */
 package propagation // import "go.opentelemetry.io/otel/propagation"

vendor/go.opentelemetry.io/otel/sdk/export/metric/aggregation/aggregation.go

@@ -64,22 +64,6 @@ type (
 		LastValue() (number.Number, time.Time, error)
 	}
 
-	// Points returns the raw values that were aggregated.
-	Points interface {
-		Aggregation
-
-		// Points returns points in the order they were
-		// recorded.  Points are approximately ordered by
-		// timestamp, but this is not guaranteed.
-		Points() ([]Point, error)
-	}
-
-	// Point is a raw data point, consisting of a number and value.
-	Point struct {
-		number.Number
-		time.Time
-	}
-
 	// Buckets represents histogram buckets boundaries and counts.
 	//
 	// For a Histogram with N defined boundaries, e.g, [x, y, z].
@@ -100,15 +84,6 @@ type (
 		Sum() (number.Number, error)
 		Histogram() (Buckets, error)
 	}
-
-	// MinMaxSumCount supports the Min, Max, Sum, and Count interfaces.
-	MinMaxSumCount interface {
-		Aggregation
-		Min() (number.Number, error)
-		Max() (number.Number, error)
-		Sum() (number.Number, error)
-		Count() (uint64, error)
-	}
 )
 
 type (
@@ -122,19 +97,16 @@ type (
 	// deciding how to expose metric data.  This enables
 	// user-supplied Aggregators to replace builtin Aggregators.
 	//
-	// For example, test for a Distribution before testing for a
-	// MinMaxSumCount, test for a Histogram before testing for a
+	// For example, test for a Histogram before testing for a
 	// Sum, and so on.
 	Kind string
 )
 
 // Kind description constants.
 const (
-	SumKind            Kind = "Sum"
-	MinMaxSumCountKind Kind = "MinMaxSumCount"
-	HistogramKind      Kind = "Histogram"
-	LastValueKind      Kind = "Lastvalue"
-	ExactKind          Kind = "Exact"
+	SumKind       Kind = "Sum"
+	HistogramKind Kind = "Histogram"
+	LastValueKind Kind = "Lastvalue"
 )
 
 // Sentinel errors for Aggregation interface.
@@ -142,7 +114,10 @@ var (
 	ErrNegativeInput    = fmt.Errorf("negative value is out of range for this instrument")
 	ErrNaNInput         = fmt.Errorf("NaN value is an invalid input")
 	ErrInconsistentType = fmt.Errorf("inconsistent aggregator types")
-	ErrNoSubtraction    = fmt.Errorf("aggregator does not subtract")
+
+	// ErrNoCumulativeToDelta is returned when requesting delta
+	// export kind for a precomputed sum instrument.
+	ErrNoCumulativeToDelta = fmt.Errorf("cumulative to delta not implemented")
 
 	// ErrNoData is returned when (due to a race with collection)
 	// the Aggregator is check-pointed before the first value is set.

vendor/go.opentelemetry.io/otel/sdk/export/metric/metric.go

@@ -139,8 +139,7 @@ type CheckpointerFactory interface {
 //
 // Note that any Aggregator may be attached to any instrument--this is
 // the result of the OpenTelemetry API/SDK separation.  It is possible
-// to attach a Sum aggregator to a Histogram instrument or a
-// MinMaxSumCount aggregator to a Counter instrument.
+// to attach a Sum aggregator to a Histogram instrument.
 type Aggregator interface {
 	// Aggregation returns an Aggregation interface to access the
 	// current state of this Aggregator.  The caller is
@@ -193,16 +192,6 @@ type Aggregator interface {
 	Merge(aggregator Aggregator, descriptor *sdkapi.Descriptor) error
 }
 
-// Subtractor is an optional interface implemented by some
-// Aggregators.  An Aggregator must support `Subtract()` in order to
-// be configured for a Precomputed-Sum instrument (CounterObserver,
-// UpDownCounterObserver) using a DeltaExporter.
-type Subtractor interface {
-	// Subtract subtracts the `operand` from this Aggregator and
-	// outputs the value in `result`.
-	Subtract(operand, result Aggregator, descriptor *sdkapi.Descriptor) error
-}
-
 // Exporter handles presentation of the checkpoint of aggregate
 // metrics.  This is the final stage of a metrics export pipeline,
 // where metric data are formatted for a specific system.

vendor/go.opentelemetry.io/otel/sdk/metric/aggregator/exact/exact.go

@@ -1,130 +0,0 @@
-// 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 exact // import "go.opentelemetry.io/otel/sdk/metric/aggregator/exact"
-
-import (
-	"context"
-	"sync"
-	"time"
-
-	"go.opentelemetry.io/otel/metric/number"
-	"go.opentelemetry.io/otel/metric/sdkapi"
-	export "go.opentelemetry.io/otel/sdk/export/metric"
-	"go.opentelemetry.io/otel/sdk/export/metric/aggregation"
-	"go.opentelemetry.io/otel/sdk/metric/aggregator"
-)
-
-type (
-	// Aggregator aggregates events that form a distribution, keeping
-	// an array with the exact set of values.
-	Aggregator struct {
-		lock    sync.Mutex
-		samples []aggregation.Point
-	}
-)
-
-var _ export.Aggregator = &Aggregator{}
-var _ aggregation.Points = &Aggregator{}
-var _ aggregation.Count = &Aggregator{}
-
-// New returns cnt many new exact aggregators, which aggregate recorded
-// measurements by storing them in an array.  This type uses a mutex
-// for Update() and SynchronizedMove() concurrency.
-func New(cnt int) []Aggregator {
-	return make([]Aggregator, cnt)
-}
-
-// Aggregation returns an interface for reading the state of this aggregator.
-func (c *Aggregator) Aggregation() aggregation.Aggregation {
-	return c
-}
-
-// Kind returns aggregation.ExactKind.
-func (c *Aggregator) Kind() aggregation.Kind {
-	return aggregation.ExactKind
-}
-
-// Count returns the number of values in the checkpoint.
-func (c *Aggregator) Count() (uint64, error) {
-	return uint64(len(c.samples)), nil
-}
-
-// Points returns access to the raw data set.
-func (c *Aggregator) Points() ([]aggregation.Point, error) {
-	return c.samples, nil
-}
-
-// SynchronizedMove saves the current state to oa and resets the current state to
-// the empty set, taking a lock to prevent concurrent Update() calls.
-func (c *Aggregator) SynchronizedMove(oa export.Aggregator, desc *sdkapi.Descriptor) error {
-	o, _ := oa.(*Aggregator)
-
-	if oa != nil && o == nil {
-		return aggregator.NewInconsistentAggregatorError(c, oa)
-	}
-
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
-	if o != nil {
-		o.samples = c.samples
-	}
-	c.samples = nil
-
-	return nil
-}
-
-// Update adds the recorded measurement to the current data set.
-// Update takes a lock to prevent concurrent Update() and SynchronizedMove()
-// calls.
-func (c *Aggregator) Update(_ context.Context, number number.Number, desc *sdkapi.Descriptor) error {
-	now := time.Now()
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	c.samples = append(c.samples, aggregation.Point{
-		Number: number,
-		Time:   now,
-	})
-
-	return nil
-}
-
-// Merge combines two data sets into one.
-func (c *Aggregator) Merge(oa export.Aggregator, desc *sdkapi.Descriptor) error {
-	o, _ := oa.(*Aggregator)
-	if o == nil {
-		return aggregator.NewInconsistentAggregatorError(c, oa)
-	}
-
-	c.samples = combine(c.samples, o.samples)
-	return nil
-}
-
-func combine(a, b []aggregation.Point) []aggregation.Point {
-	result := make([]aggregation.Point, 0, len(a)+len(b))
-
-	for len(a) != 0 && len(b) != 0 {
-		if a[0].Time.Before(b[0].Time) {
-			result = append(result, a[0])
-			a = a[1:]
-		} else {
-			result = append(result, b[0])
-			b = b[1:]
-		}
-	}
-	result = append(result, a...)
-	result = append(result, b...)
-	return result
-}

vendor/go.opentelemetry.io/otel/sdk/metric/aggregator/minmaxsumcount/mmsc.go

@@ -1,165 +0,0 @@
-// 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 minmaxsumcount // import "go.opentelemetry.io/otel/sdk/metric/aggregator/minmaxsumcount"
-
-import (
-	"context"
-	"sync"
-
-	"go.opentelemetry.io/otel/metric/number"
-	"go.opentelemetry.io/otel/metric/sdkapi"
-	export "go.opentelemetry.io/otel/sdk/export/metric"
-	"go.opentelemetry.io/otel/sdk/export/metric/aggregation"
-	"go.opentelemetry.io/otel/sdk/metric/aggregator"
-)
-
-type (
-	// Aggregator aggregates events that form a distribution,
-	// keeping only the min, max, sum, and count.
-	Aggregator struct {
-		lock sync.Mutex
-		kind number.Kind
-		state
-	}
-
-	state struct {
-		sum   number.Number
-		min   number.Number
-		max   number.Number
-		count uint64
-	}
-)
-
-var _ export.Aggregator = &Aggregator{}
-var _ aggregation.MinMaxSumCount = &Aggregator{}
-
-// New returns a new aggregator for computing the min, max, sum, and
-// count.
-//
-// This type uses a mutex for Update() and SynchronizedMove() concurrency.
-func New(cnt int, desc *sdkapi.Descriptor) []Aggregator {
-	kind := desc.NumberKind()
-	aggs := make([]Aggregator, cnt)
-	for i := range aggs {
-		aggs[i] = Aggregator{
-			kind:  kind,
-			state: emptyState(kind),
-		}
-	}
-	return aggs
-}
-
-// Aggregation returns an interface for reading the state of this aggregator.
-func (c *Aggregator) Aggregation() aggregation.Aggregation {
-	return c
-}
-
-// Kind returns aggregation.MinMaxSumCountKind.
-func (c *Aggregator) Kind() aggregation.Kind {
-	return aggregation.MinMaxSumCountKind
-}
-
-// Sum returns the sum of values in the checkpoint.
-func (c *Aggregator) Sum() (number.Number, error) {
-	return c.sum, nil
-}
-
-// Count returns the number of values in the checkpoint.
-func (c *Aggregator) Count() (uint64, error) {
-	return c.count, nil
-}
-
-// Min returns the minimum value in the checkpoint.
-// The error value aggregation.ErrNoData will be returned
-// if there were no measurements recorded during the checkpoint.
-func (c *Aggregator) Min() (number.Number, error) {
-	if c.count == 0 {
-		return 0, aggregation.ErrNoData
-	}
-	return c.min, nil
-}
-
-// Max returns the maximum value in the checkpoint.
-// The error value aggregation.ErrNoData will be returned
-// if there were no measurements recorded during the checkpoint.
-func (c *Aggregator) Max() (number.Number, error) {
-	if c.count == 0 {
-		return 0, aggregation.ErrNoData
-	}
-	return c.max, nil
-}
-
-// SynchronizedMove saves the current state into oa and resets the current state to
-// the empty set.
-func (c *Aggregator) SynchronizedMove(oa export.Aggregator, desc *sdkapi.Descriptor) error {
-	o, _ := oa.(*Aggregator)
-
-	if oa != nil && o == nil {
-		return aggregator.NewInconsistentAggregatorError(c, oa)
-	}
-	c.lock.Lock()
-	if o != nil {
-		o.state = c.state
-	}
-	c.state = emptyState(c.kind)
-	c.lock.Unlock()
-
-	return nil
-}
-
-func emptyState(kind number.Kind) state {
-	return state{
-		count: 0,
-		sum:   0,
-		min:   kind.Maximum(),
-		max:   kind.Minimum(),
-	}
-}
-
-// Update adds the recorded measurement to the current data set.
-func (c *Aggregator) Update(_ context.Context, number number.Number, desc *sdkapi.Descriptor) error {
-	kind := desc.NumberKind()
-
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	c.count++
-	c.sum.AddNumber(kind, number)
-	if number.CompareNumber(kind, c.min) < 0 {
-		c.min = number
-	}
-	if number.CompareNumber(kind, c.max) > 0 {
-		c.max = number
-	}
-	return nil
-}
-
-// Merge combines two data sets into one.
-func (c *Aggregator) Merge(oa export.Aggregator, desc *sdkapi.Descriptor) error {
-	o, _ := oa.(*Aggregator)
-	if o == nil {
-		return aggregator.NewInconsistentAggregatorError(c, oa)
-	}
-
-	c.count += o.count
-	c.sum.AddNumber(desc.NumberKind(), o.sum)
-
-	if c.min.CompareNumber(desc.NumberKind(), o.min) > 0 {
-		c.min.SetNumber(o.min)
-	}
-	if c.max.CompareNumber(desc.NumberKind(), o.max) < 0 {
-		c.max.SetNumber(o.max)
-	}
-	return nil
-}

vendor/go.opentelemetry.io/otel/sdk/metric/aggregator/sum/sum.go

@@ -32,7 +32,6 @@ type Aggregator struct {
 }
 
 var _ export.Aggregator = &Aggregator{}
-var _ export.Subtractor = &Aggregator{}
 var _ aggregation.Sum = &Aggregator{}
 
 // New returns a new counter aggregator implemented by atomic
@@ -88,19 +87,3 @@ func (c *Aggregator) Merge(oa export.Aggregator, desc *sdkapi.Descriptor) error
 	c.value.AddNumber(desc.NumberKind(), o.value)
 	return nil
 }
-
-func (c *Aggregator) Subtract(opAgg, resAgg export.Aggregator, descriptor *sdkapi.Descriptor) error {
-	op, _ := opAgg.(*Aggregator)
-	if op == nil {
-		return aggregator.NewInconsistentAggregatorError(c, opAgg)
-	}
-
-	res, _ := resAgg.(*Aggregator)
-	if res == nil {
-		return aggregator.NewInconsistentAggregatorError(c, resAgg)
-	}
-
-	res.value = c.value
-	res.value.AddNumber(descriptor.NumberKind(), number.NewNumberSignChange(descriptor.NumberKind(), op.value))
-	return nil
-}

vendor/go.opentelemetry.io/otel/sdk/metric/controller/basic/controller.go

@@ -56,14 +56,9 @@ var ErrControllerStarted = fmt.Errorf("controller already started")
 // using the export.Reader RWLock interface.  Collection will
 // be blocked by a pull request in the basic controller.
 type Controller struct {
-	// lock protects libraries and synchronizes Start() and Stop().
-	lock sync.Mutex
-	// TODO: libraries is synchronized by lock, but could be
-	// accomplished using a sync.Map.  The SDK specification will
-	// probably require this, as the draft already states that
-	// Stop() and MeterProvider.Meter() should not block each
-	// other.
-	libraries           map[instrumentation.Library]*registry.UniqueInstrumentMeterImpl
+	// lock synchronizes Start() and Stop().
+	lock                sync.Mutex
+	libraries           sync.Map
 	checkpointerFactory export.CheckpointerFactory
 
 	resource *resource.Resource
@@ -93,21 +88,18 @@ func (c *Controller) Meter(instrumentationName string, opts ...metric.MeterOptio
 		SchemaURL: cfg.SchemaURL(),
 	}
 
-	c.lock.Lock()
-	defer c.lock.Unlock()
-	m, ok := c.libraries[library]
+	m, ok := c.libraries.Load(library)
 	if !ok {
 		checkpointer := c.checkpointerFactory.NewCheckpointer()
-		accumulator := sdk.NewAccumulator(checkpointer)
-		m = registry.NewUniqueInstrumentMeterImpl(&accumulatorCheckpointer{
-			Accumulator:  accumulator,
-			checkpointer: checkpointer,
-			library:      library,
-		})
-
-		c.libraries[library] = m
+		m, _ = c.libraries.LoadOrStore(
+			library,
+			registry.NewUniqueInstrumentMeterImpl(&accumulatorCheckpointer{
+				Accumulator:  sdk.NewAccumulator(checkpointer),
+				checkpointer: checkpointer,
+				library:      library,
+			}))
 	}
-	return metric.WrapMeterImpl(m)
+	return metric.WrapMeterImpl(m.(*registry.UniqueInstrumentMeterImpl))
 }
 
 type accumulatorCheckpointer struct {
@@ -138,7 +130,6 @@ func New(checkpointerFactory export.CheckpointerFactory, opts ...Option) *Contro
 		}
 	}
 	return &Controller{
-		libraries:           map[instrumentation.Library]*registry.UniqueInstrumentMeterImpl{},
 		checkpointerFactory: checkpointerFactory,
 		exporter:            c.Exporter,
 		resource:            c.Resource,
@@ -251,16 +242,14 @@ func (c *Controller) collect(ctx context.Context) error {
 // accumulatorList returns a snapshot of current accumulators
 // registered to this controller.  This briefly locks the controller.
 func (c *Controller) accumulatorList() []*accumulatorCheckpointer {
-	c.lock.Lock()
-	defer c.lock.Unlock()
-
 	var r []*accumulatorCheckpointer
-	for _, entry := range c.libraries {
-		acc, ok := entry.MeterImpl().(*accumulatorCheckpointer)
+	c.libraries.Range(func(key, value interface{}) bool {
+		acc, ok := value.(*registry.UniqueInstrumentMeterImpl).MeterImpl().(*accumulatorCheckpointer)
 		if ok {
 			r = append(r, acc)
 		}
-	}
+		return true
+	})
 	return r
 }
 

vendor/go.opentelemetry.io/otel/sdk/metric/doc.go

@@ -28,9 +28,7 @@ and asynchronous instruments.  There are two constructors per instrument for
 the two kinds of number (int64, float64).
 
 Synchronous instruments are managed by a sync.Map containing a *record
-with the current state for each synchronous instrument.  A bound
-instrument encapsulates a direct pointer to the record, allowing
-bound metric events to bypass a sync.Map lookup.  A lock-free
+with the current state for each synchronous instrument.  A lock-free
 algorithm is used to protect against races when adding and removing
 items from the sync.Map.
 
@@ -45,7 +43,7 @@ record contains a set of recorders for every specific label set used in the
 callback.
 
 A sync.Map maintains the mapping of current instruments and label sets to
-internal records.  To create a new bound instrument, the SDK consults the Map to
+internal records.  To find a record, the SDK consults the Map to
 locate an existing record, otherwise it constructs a new record.  The SDK
 maintains a count of the number of references to each record, ensuring
 that records are not reclaimed from the Map while they are still active

vendor/go.opentelemetry.io/otel/sdk/metric/processor/basic/basic.go

@@ -76,11 +76,6 @@ type (
 		// values in a single collection round.
 		current export.Aggregator
 
-		// delta, if non-nil, refers to an Aggregator owned by
-		// the processor used to compute deltas between
-		// precomputed sums.
-		delta export.Aggregator
-
 		// cumulative, if non-nil, refers to an Aggregator owned
 		// by the processor used to store the last cumulative
 		// value.
@@ -94,9 +89,6 @@ type (
 		sync.RWMutex
 		values map[stateKey]*stateValue
 
-		// Note: the timestamp logic currently assumes all
-		// exports are deltas.
-
 		processStart  time.Time
 		intervalStart time.Time
 		intervalEnd   time.Time
@@ -124,8 +116,8 @@ var ErrInvalidTemporality = fmt.Errorf("invalid aggregation temporality")
 // New returns a basic Processor that is also a Checkpointer using the provided
 // AggregatorSelector to select Aggregators.  The TemporalitySelector
 // is consulted to determine the kind(s) of exporter that will consume
-// data, so that this Processor can prepare to compute Delta or
-// Cumulative Aggregations as needed.
+// data, so that this Processor can prepare to compute Cumulative Aggregations
+// as needed.
 func New(aselector export.AggregatorSelector, tselector aggregation.TemporalitySelector, opts ...Option) *Processor {
 	return NewFactory(aselector, tselector, opts...).NewCheckpointer().(*Processor)
 }
@@ -191,13 +183,17 @@ func (b *Processor) Process(accum export.Accumulation) error {
 		}
 		if stateful {
 			if desc.InstrumentKind().PrecomputedSum() {
-				// If we know we need to compute deltas, allocate two aggregators.
-				b.AggregatorFor(desc, &newValue.cumulative, &newValue.delta)
-			} else {
-				// In this case we are certain not to need a delta, only allocate
-				// a cumulative aggregator.
-				b.AggregatorFor(desc, &newValue.cumulative)
+				// To convert precomputed sums to
+				// deltas requires two aggregators to
+				// be allocated, one for the prior
+				// value and one for the output delta.
+				// This functionality was removed from
+				// the basic processor in PR #2350.
+				return aggregation.ErrNoCumulativeToDelta
 			}
+			// In this case allocate one aggregator to
+			// save the current state.
+			b.AggregatorFor(desc, &newValue.cumulative)
 		}
 		b.state.values[key] = newValue
 		return nil
@@ -310,28 +306,15 @@ func (b *Processor) FinishCollection() error {
 			continue
 		}
 
-		// Update Aggregator state to support exporting either a
-		// delta or a cumulative aggregation.
-		var err error
-		if mkind.PrecomputedSum() {
-			if currentSubtractor, ok := value.current.(export.Subtractor); ok {
-				// This line is equivalent to:
-				// value.delta = currentSubtractor - value.cumulative
-				err = currentSubtractor.Subtract(value.cumulative, value.delta, key.descriptor)
-
-				if err == nil {
-					err = value.current.SynchronizedMove(value.cumulative, key.descriptor)
-				}
-			} else {
-				err = aggregation.ErrNoSubtraction
-			}
-		} else {
+		// The only kind of aggregators that are not stateless
+		// are the ones needing delta to cumulative
+		// conversion.  Merge aggregator state in this case.
+		if !mkind.PrecomputedSum() {
 			// This line is equivalent to:
-			// value.cumulative = value.cumulative + value.delta
-			err = value.cumulative.Merge(value.current, key.descriptor)
-		}
-		if err != nil {
-			return err
+			// value.cumulative = value.cumulative + value.current
+			if err := value.cumulative.Merge(value.current, key.descriptor); err != nil {
+				return err
+			}
 		}
 	}
 	return nil
@@ -350,13 +333,8 @@ func (b *state) ForEach(exporter aggregation.TemporalitySelector, f func(export.
 		var agg aggregation.Aggregation
 		var start time.Time
 
-		// If the processor does not have Config.Memory and it was not updated
-		// in the prior round, do not visit this value.
-		if !b.config.Memory && value.updated != (b.finishedCollection-1) {
-			continue
-		}
-
 		aggTemp := exporter.TemporalityFor(key.descriptor, value.current.Aggregation().Kind())
+
 		switch aggTemp {
 		case aggregation.CumulativeTemporality:
 			// If stateful, the sum has been computed.  If stateless, the
@@ -372,16 +350,23 @@ func (b *state) ForEach(exporter aggregation.TemporalitySelector, f func(export.
 		case aggregation.DeltaTemporality:
 			// Precomputed sums are a special case.
 			if mkind.PrecomputedSum() {
-				agg = value.delta.Aggregation()
-			} else {
-				agg = value.current.Aggregation()
+				// This functionality was removed from
+				// the basic processor in PR #2350.
+				return aggregation.ErrNoCumulativeToDelta
 			}
+			agg = value.current.Aggregation()
 			start = b.intervalStart
 
 		default:
 			return fmt.Errorf("%v: %w", aggTemp, ErrInvalidTemporality)
 		}
 
+		// If the processor does not have Config.Memory and it was not updated
+		// in the prior round, do not visit this value.
+		if !b.config.Memory && value.updated != (b.finishedCollection-1) {
+			continue
+		}
+
 		if err := f(export.NewRecord(
 			key.descriptor,
 			value.labels,

vendor/go.opentelemetry.io/otel/sdk/metric/sdk.go

@@ -138,10 +138,9 @@ type (
 )
 
 var (
-	_ sdkapi.MeterImpl     = &Accumulator{}
-	_ sdkapi.AsyncImpl     = &asyncInstrument{}
-	_ sdkapi.SyncImpl      = &syncInstrument{}
-	_ sdkapi.BoundSyncImpl = &record{}
+	_ sdkapi.MeterImpl = &Accumulator{}
+	_ sdkapi.AsyncImpl = &asyncInstrument{}
+	_ sdkapi.SyncImpl  = &syncInstrument{}
 
 	// ErrUninitializedInstrument is returned when an instrument is used when uninitialized.
 	ErrUninitializedInstrument = fmt.Errorf("use of an uninitialized instrument")
@@ -279,15 +278,10 @@ func (s *syncInstrument) acquireHandle(kvs []attribute.KeyValue, labelPtr *attri
 	}
 }
 
-// The order of the input array `kvs` may be sorted after the function is called.
-func (s *syncInstrument) Bind(kvs []attribute.KeyValue) sdkapi.BoundSyncImpl {
-	return s.acquireHandle(kvs, nil)
-}
-
 // The order of the input array `kvs` may be sorted after the function is called.
 func (s *syncInstrument) RecordOne(ctx context.Context, num number.Number, kvs []attribute.KeyValue) {
 	h := s.acquireHandle(kvs, nil)
-	defer h.Unbind()
+	defer h.unbind()
 	h.RecordOne(ctx, num)
 }
 
@@ -490,7 +484,7 @@ func (m *Accumulator) RecordBatch(ctx context.Context, kvs []attribute.KeyValue,
 			labelsPtr = h.labels
 		}
 
-		defer h.Unbind()
+		defer h.unbind()
 		h.RecordOne(ctx, meas.Number())
 	}
 }
@@ -514,8 +508,7 @@ func (r *record) RecordOne(ctx context.Context, num number.Number) {
 	atomic.AddInt64(&r.updateCount, 1)
 }
 
-// Unbind implements sdkapi.SyncImpl.
-func (r *record) Unbind() {
+func (r *record) unbind() {
 	r.refMapped.unref()
 }
 

vendor/go.opentelemetry.io/otel/sdk/metric/selector/simple/simple.go

@@ -17,16 +17,13 @@ package simple // import "go.opentelemetry.io/otel/sdk/metric/selector/simple"
 import (
 	"go.opentelemetry.io/otel/metric/sdkapi"
 	export "go.opentelemetry.io/otel/sdk/export/metric"
-	"go.opentelemetry.io/otel/sdk/metric/aggregator/exact"
 	"go.opentelemetry.io/otel/sdk/metric/aggregator/histogram"
 	"go.opentelemetry.io/otel/sdk/metric/aggregator/lastvalue"
-	"go.opentelemetry.io/otel/sdk/metric/aggregator/minmaxsumcount"
 	"go.opentelemetry.io/otel/sdk/metric/aggregator/sum"
 )
 
 type (
 	selectorInexpensive struct{}
-	selectorExact       struct{}
 	selectorHistogram   struct {
 		options []histogram.Option
 	}
@@ -34,7 +31,6 @@ type (
 
 var (
 	_ export.AggregatorSelector = selectorInexpensive{}
-	_ export.AggregatorSelector = selectorExact{}
 	_ export.AggregatorSelector = selectorHistogram{}
 )
 
@@ -47,15 +43,6 @@ func NewWithInexpensiveDistribution() export.AggregatorSelector {
 	return selectorInexpensive{}
 }
 
-// NewWithExactDistribution returns a simple aggregator selector that
-// uses exact aggregators for `Histogram` instruments.  This
-// selector uses more memory than the others in this package because
-// exact aggregators maintain the most information about the
-// distribution among these choices.
-func NewWithExactDistribution() export.AggregatorSelector {
-	return selectorExact{}
-}
-
 // NewWithHistogramDistribution returns a simple aggregator selector
 // that uses histogram aggregators for `Histogram` instruments.
 // This selector is a good default choice for most metric exporters.
@@ -82,21 +69,7 @@ func (selectorInexpensive) AggregatorFor(descriptor *sdkapi.Descriptor, aggPtrs
 	case sdkapi.GaugeObserverInstrumentKind:
 		lastValueAggs(aggPtrs)
 	case sdkapi.HistogramInstrumentKind:
-		aggs := minmaxsumcount.New(len(aggPtrs), descriptor)
-		for i := range aggPtrs {
-			*aggPtrs[i] = &aggs[i]
-		}
-	default:
-		sumAggs(aggPtrs)
-	}
-}
-
-func (selectorExact) AggregatorFor(descriptor *sdkapi.Descriptor, aggPtrs ...*export.Aggregator) {
-	switch descriptor.InstrumentKind() {
-	case sdkapi.GaugeObserverInstrumentKind:
-		lastValueAggs(aggPtrs)
-	case sdkapi.HistogramInstrumentKind:
-		aggs := exact.New(len(aggPtrs))
+		aggs := sum.New(len(aggPtrs))
 		for i := range aggPtrs {
 			*aggPtrs[i] = &aggs[i]
 		}

vendor/go.opentelemetry.io/otel/sdk/resource/resource.go

@@ -18,6 +18,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"sync"
 
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/attribute"
@@ -36,26 +37,12 @@ type Resource struct {
 }
 
 var (
-	emptyResource Resource
-
-	defaultResource = func(r *Resource, err error) *Resource {
-		if err != nil {
-			otel.Handle(err)
-		}
-		return r
-	}(
-		Detect(
-			context.Background(),
-			defaultServiceNameDetector{},
-			fromEnv{},
-			telemetrySDK{},
-		),
-	)
+	emptyResource       Resource
+	defaultResource     *Resource
+	defaultResourceOnce sync.Once
 )
 
-var (
-	errMergeConflictSchemaURL = errors.New("cannot merge resource due to conflicting Schema URL")
-)
+var errMergeConflictSchemaURL = errors.New("cannot merge resource due to conflicting Schema URL")
 
 // New returns a Resource combined from the user-provided detectors.
 func New(ctx context.Context, opts ...Option) (*Resource, error) {
@@ -211,6 +198,22 @@ func Empty() *Resource {
 // Default returns an instance of Resource with a default
 // "service.name" and OpenTelemetrySDK attributes.
 func Default() *Resource {
+	defaultResourceOnce.Do(func() {
+		var err error
+		defaultResource, err = Detect(
+			context.Background(),
+			defaultServiceNameDetector{},
+			fromEnv{},
+			telemetrySDK{},
+		)
+		if err != nil {
+			otel.Handle(err)
+		}
+		// If Detect did not return a valid resource, fall back to emptyResource.
+		if defaultResource == nil {
+			defaultResource = &emptyResource
+		}
+	})
 	return defaultResource
 }
 

vendor/go.opentelemetry.io/otel/semconv/v1.7.0/http.go

@@ -21,6 +21,8 @@ import (
 	"strconv"
 	"strings"
 
+	"go.opentelemetry.io/otel/trace"
+
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 )
@@ -269,6 +271,21 @@ func SpanStatusFromHTTPStatusCode(code int) (codes.Code, string) {
 	return spanCode, ""
 }
 
+// SpanStatusFromHTTPStatusCodeAndSpanKind generates a status code and a message
+// as specified by the OpenTelemetry specification for a span.
+// Exclude 4xx for SERVER to set the appropriate status.
+func SpanStatusFromHTTPStatusCodeAndSpanKind(code int, spanKind trace.SpanKind) (codes.Code, string) {
+	spanCode, valid := validateHTTPStatusCode(code)
+	if !valid {
+		return spanCode, fmt.Sprintf("Invalid HTTP status code %d", code)
+	}
+	category := code / 100
+	if spanKind == trace.SpanKindServer && category == 4 {
+		return codes.Unset, ""
+	}
+	return spanCode, ""
+}
+
 // Validates the HTTP status code and returns corresponding span status code.
 // If the `code` is not a valid HTTP status code, returns span status Error
 // and false.

vendor/go.opentelemetry.io/otel/version.go

@@ -16,5 +16,5 @@ package otel // import "go.opentelemetry.io/otel"
 
 // Version is the current release version of OpenTelemetry in use.
 func Version() string {
-	return "1.2.0"
+	return "1.3.0"
 }

vendor/go.opentelemetry.io/otel/versions.yaml

@@ -14,7 +14,7 @@
 
 module-sets:
   stable-v1:
-    version: v1.2.0
+    version: v1.3.0
     modules:
       - go.opentelemetry.io/otel
       - go.opentelemetry.io/otel/bridge/opentracing
@@ -29,11 +29,12 @@ module-sets:
       - go.opentelemetry.io/otel/exporters/otlp/otlptrace
       - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
       - go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
+      - go.opentelemetry.io/otel/exporters/otlp/internal/retry
       - go.opentelemetry.io/otel/exporters/stdout/stdouttrace
       - go.opentelemetry.io/otel/trace
       - go.opentelemetry.io/otel/sdk
   experimental-metrics:
-    version: v0.25.0
+    version: v0.26.0
     modules:
       - go.opentelemetry.io/otel/example/prometheus
       - go.opentelemetry.io/otel/exporters/otlp/otlpmetric
@@ -50,7 +51,7 @@ module-sets:
     modules:
       - go.opentelemetry.io/otel/schema
   bridge:
-    version: v0.25.0
+    version: v0.26.0
     modules:
       - go.opentelemetry.io/otel/bridge/opencensus
       - go.opentelemetry.io/otel/bridge/opencensus/test