Bump otel dependencies to v1.4.0/v0.29.0

Signed-off-by: CrazyMax <crazy-max@users.noreply.github.com>
2022-02-15 07:18:29 +01:00 · 2022-02-15 07:18:29 +01:00 · e109747340
parent 1fbdce1d05
commit e109747340
57 changed files with 941 additions and 1044 deletions
--- a/go.mod
+++ b/go.mod
@ -27,7 +27,7 @@ require (
 	github.com/gogo/googleapis v1.4.1
 	github.com/gogo/protobuf v1.3.2
 	github.com/golang/protobuf v1.5.2
-	github.com/google/go-cmp v0.5.6
+	github.com/google/go-cmp v0.5.7
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/grpc-ecosystem/go-grpc-middleware v1.3.0
 	github.com/hashicorp/go-immutable-radix v1.3.1
@ -59,17 +59,17 @@ require (
 	github.com/tonistiigi/vt100 v0.0.0-20210615222946-8066bb97264f
 	github.com/urfave/cli v1.22.4
 	go.etcd.io/bbolt v1.3.6
-	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.28.0
-	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.27.1-0.20211201163413-2bb24f926b80 // https://github.com/open-telemetry/opentelemetry-go-contrib/pull/874
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.28.1-0.20220111222512-7e31ebe04030 // https://github.com/open-telemetry/opentelemetry-go-contrib/pull/875
-	go.opentelemetry.io/otel v1.3.0
-	go.opentelemetry.io/otel/exporters/jaeger v1.3.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.3.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0
-	go.opentelemetry.io/otel/sdk v1.3.0
-	go.opentelemetry.io/otel/trace v1.3.0
-	go.opentelemetry.io/proto/otlp v0.11.0
+	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.29.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.29.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.29.0
+	go.opentelemetry.io/otel v1.4.0
+	go.opentelemetry.io/otel/exporters/jaeger v1.4.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.4.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.4.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.4.0
+	go.opentelemetry.io/otel/sdk v1.4.0
+	go.opentelemetry.io/otel/trace v1.4.0
+	go.opentelemetry.io/proto/otlp v0.12.0
 	golang.org/x/crypto v0.0.0-20211202192323-5770296d904e
 	golang.org/x/net v0.0.0-20211216030914-fe4d6282115f
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
@ -116,9 +116,9 @@ require (
 	github.com/shurcooL/sanitized_anchor_name v1.0.0 // indirect
 	github.com/vbatts/tar-split v0.11.2 // indirect
 	go.opencensus.io v0.23.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.3.0 // indirect
-	go.opentelemetry.io/otel/internal/metric v0.26.0 // indirect
-	go.opentelemetry.io/otel/metric v0.26.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.4.0 // indirect
+	go.opentelemetry.io/otel/internal/metric v0.27.0 // indirect
+	go.opentelemetry.io/otel/metric v0.27.0 // indirect
 	golang.org/x/text v0.3.7 // indirect
 	google.golang.org/protobuf v1.27.1 // indirect
 	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
--- a/go.sum
+++ b/go.sum
@ -663,8 +663,9 @@ github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 github.com/google/go-cmp v0.5.3/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
-github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
 github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o=
+github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE=
 github.com/google/go-containerregistry v0.0.0-20191010200024-a3d713f9b7f8/go.mod h1:KyKXa9ciM8+lgMXwOVsXi7UxGrsf9mM61Mzs+xKUrKE=
 github.com/google/go-containerregistry v0.1.2/go.mod h1:GPivBPgdAyd2SU+vf6EpsgOtWDuPqjW0hJZt4rNdTZ4=
 github.com/google/go-containerregistry v0.5.1/go.mod h1:Ct15B4yir3PLOP5jsy0GNeYVaIZs/MK/Jz5any1wFW0=
@ -1324,47 +1325,54 @@ go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/contrib v0.20.0 h1:ubFQUn0VCZ0gPwIoJfBJVpeBlyRMxu8Mm/huKWYd9p0=
 go.opentelemetry.io/contrib v0.20.0/go.mod h1:G/EtFaa6qaN7+LxqfIAT3GiZa7Wv5DTBUzl5H4LY0Kc=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.20.0/go.mod h1:oVGt1LRbBOBq1A5BQLlUg9UaU/54aiHw8cgjV3aWZ/E=
-go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.28.0 h1:Ky1MObd188aGbgb5OgNnwGuEEwI9MVIcc7rBW6zk5Ak=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.28.0/go.mod h1:vEhqr0m4eTc+DWxfsXoXue2GBgV2uUwVznkGIHW/e5w=
-go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.27.1-0.20211201163413-2bb24f926b80 h1:jofr8vPPRwgd1Z3dIpVmJ1TuYaYSHTUvOB+BngCpuKA=
-go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.27.1-0.20211201163413-2bb24f926b80/go.mod h1:zCf+wGILpPxOvJY3ZbqPz1pa5phMScFXVhhwa6knQlg=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.29.0 h1:n9b7AAdbQtQ0k9dm0Dm2/KUcUqtG8i2O15KzNaDze8c=
+go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.29.0/go.mod h1:LsankqVDx4W+RhZNA5uWarULII/MBhF5qwCYxTuyXjs=
+go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.29.0 h1:Wjp9vsVSIEyvdiaECfqxY9xBqQ7JaSCGtvHgR4doXZk=
+go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.29.0/go.mod h1:vHItvsnJtp7ES++nFLLFBzUWny7fJQSvTlxFcqQGUr4=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.20.0/go.mod h1:2AboqHi0CiIZU0qwhtUfCYD1GeUzvvIXWNkhDt7ZMG4=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.28.1-0.20220111222512-7e31ebe04030 h1:UY7EGos9NAfUImvpQ1OnP5FCTKETWpHdiWLnZ6E3Rn0=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.28.1-0.20220111222512-7e31ebe04030/go.mod h1:Ihno+mNBfZlT0Qot3XyRTdZ/9U/Cg2Pfgj75DTdIfq4=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.29.0 h1:SLme4Porm+UwX0DdHMxlwRt7FzPSE0sys81bet2o0pU=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.29.0/go.mod h1:tLYsuf2v8fZreBVwp9gVMhefZlLFZaUiNVSq8QxXRII=
 go.opentelemetry.io/otel v0.20.0/go.mod h1:Y3ugLH2oa81t5QO+Lty+zXf8zC9L26ax4Nzoxm/dooo=
-go.opentelemetry.io/otel v1.2.0/go.mod h1:aT17Fk0Z1Nor9e0uisf98LrntPGMnk4frBO9+dkf69I=
-go.opentelemetry.io/otel v1.3.0 h1:APxLf0eiBwLl+SOXiJJCVYzA1OOJNyAoV8C5RNRyy7Y=
 go.opentelemetry.io/otel v1.3.0/go.mod h1:PWIKzi6JCp7sM0k9yZ43VX+T345uNbAkDKwHVjb2PTs=
-go.opentelemetry.io/otel/exporters/jaeger v1.3.0 h1:HfydzioALdtcB26H5WHc4K47iTETJCdloL7VN579/L0=
-go.opentelemetry.io/otel/exporters/jaeger v1.3.0/go.mod h1:KoYHi1BtkUPncGSRtCe/eh1ijsnePhSkxwzz07vU0Fc=
+go.opentelemetry.io/otel v1.4.0 h1:7ESuKPq6zpjRaY5nvVDGiuwK7VAJ8MwkKnmNJ9whNZ4=
+go.opentelemetry.io/otel v1.4.0/go.mod h1:jeAqMFKy2uLIxCtKxoFj0FAL5zAPKQagc3+GtBWakzk=
+go.opentelemetry.io/otel/exporters/jaeger v1.4.0 h1:EX/spHhVkHbobTeSozT1zpbuc3oO70CISkw+dspgR9M=
+go.opentelemetry.io/otel/exporters/jaeger v1.4.0/go.mod h1:C4UfuVfyi7qAk/PAz6QodaEkES7RnLNHeAAj6QOu2gI=
 go.opentelemetry.io/otel/exporters/otlp v0.20.0 h1:PTNgq9MRmQqqJY0REVbZFvwkYOA85vbdQU/nVfxDyqg=
 go.opentelemetry.io/otel/exporters/otlp v0.20.0/go.mod h1:YIieizyaN77rtLJra0buKiNBOm9XQfkPEKBeuhoMwAM=
-go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.3.0 h1:R/OBkMoGgfy2fLhs2QhkCI1w4HLEQX92GCcJB6SSdNk=
 go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.3.0/go.mod h1:VpP4/RMn8bv8gNo9uK7/IMY4mtWLELsS+JIP0inH0h4=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0 h1:giGm8w67Ja7amYNfYMdme7xSp2pIxThWopw8+QP51Yk=
+go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.4.0 h1:j7AwzDdAQBJjcqayAaYbvpYeZzII7cEe5qJTu+De6UY=
+go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.4.0/go.mod h1:VpP4/RMn8bv8gNo9uK7/IMY4mtWLELsS+JIP0inH0h4=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0/go.mod h1:hO1KLR7jcKaDDKDkvI9dP/FIhpmna5lkqPUQdEjFAM8=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.3.0 h1:VQbUHoJqytHHSJ1OZodPH9tvZZSVzUHjPHpkO85sT6k=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.4.0 h1:lRpP10E8oTGVmY1nVXcwelCT1Z8ca41/l5ce7AqLAss=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.4.0/go.mod h1:3oS+j2WUoJVyj6/BzQN/52G17lNJDulngsOxDm1w2PY=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.3.0/go.mod h1:keUU7UfnwWTWpJ+FWnyqmogPa82nuU5VUANFq49hlMY=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0 h1:Ydage/P0fRrSPpZeCVxzjqGcI6iVmG2xb43+IR8cjqM=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.4.0 h1:buSx4AMC/0Z232slPhicN/fU5KIlj0bMngct5pcZhkI=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.4.0/go.mod h1:ew1NcwkHo0QFT3uTm3m2IVZMkZdVIpbOYNPasgWwpdk=
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0/go.mod h1:QNX1aly8ehqqX1LEa6YniTU7VY9I6R3X/oPxhGdTceE=
-go.opentelemetry.io/otel/internal/metric v0.26.0 h1:dlrvawyd/A+X8Jp0EBT4wWEe4k5avYaXsXrBr4dbfnY=
-go.opentelemetry.io/otel/internal/metric v0.26.0/go.mod h1:CbBP6AxKynRs3QCbhklyLUtpfzbqCLiafV9oY2Zj1Jk=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.4.0 h1:qAPN8Sg/Y9djLCMznn5hWGQp89/u8RYipPMVqbOXhSs=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.4.0/go.mod h1:MJtea6P7VGPZY9pkUg0yAt83WFVPNm1p2GNr2Lhzad0=
+go.opentelemetry.io/otel/internal/metric v0.27.0 h1:9dAVGAfFiiEq5NVB9FUJ5et+btbDQAUIJehJ+ikyryk=
+go.opentelemetry.io/otel/internal/metric v0.27.0/go.mod h1:n1CVxRqKqYZtqyTh9U/onvKapPGv7y/rpyOTI+LFNzw=
 go.opentelemetry.io/otel/metric v0.20.0/go.mod h1:598I5tYlH1vzBjn+BTuhzTCSb/9debfNp6R3s7Pr1eU=
-go.opentelemetry.io/otel/metric v0.26.0 h1:VaPYBTvA13h/FsiWfxa3yZnZEm15BhStD8JZQSA773M=
-go.opentelemetry.io/otel/metric v0.26.0/go.mod h1:c6YL0fhRo4YVoNs6GoByzUgBp36hBL523rECoZA5UWg=
+go.opentelemetry.io/otel/metric v0.27.0 h1:HhJPsGhJoKRSegPQILFbODU56NS/L1UE4fS1sC5kIwQ=
+go.opentelemetry.io/otel/metric v0.27.0/go.mod h1:raXDJ7uP2/Jc0nVZWQjJtzoyssOYWu/+pjZqRzfvZ7g=
 go.opentelemetry.io/otel/oteltest v0.20.0/go.mod h1:L7bgKf9ZB7qCwT9Up7i9/pn0PWIa9FqQ2IQ8LoxiGnw=
 go.opentelemetry.io/otel/sdk v0.20.0/go.mod h1:g/IcepuwNsoiX5Byy2nNV0ySUF1em498m7hBWC279Yc=
-go.opentelemetry.io/otel/sdk v1.3.0 h1:3278edCoH89MEJ0Ky8WQXVmDQv3FX4ZJ3Pp+9fJreAI=
 go.opentelemetry.io/otel/sdk v1.3.0/go.mod h1:rIo4suHNhQwBIPg9axF8V9CA72Wz2mKF1teNrup8yzs=
+go.opentelemetry.io/otel/sdk v1.4.0 h1:LJE4SW3jd4lQTESnlpQZcBhQ3oci0U2MLR5uhicfTHQ=
+go.opentelemetry.io/otel/sdk v1.4.0/go.mod h1:71GJPNJh4Qju6zJuYl1CrYtXbrgfau/M9UAggqiy1UE=
 go.opentelemetry.io/otel/sdk/export/metric v0.20.0/go.mod h1:h7RBNMsDJ5pmI1zExLi+bJK+Dr8NQCh0qGhm1KDnNlE=
 go.opentelemetry.io/otel/sdk/metric v0.20.0/go.mod h1:knxiS8Xd4E/N+ZqKmUPf3gTTZ4/0TjTXukfxjzSTpHE=
 go.opentelemetry.io/otel/trace v0.20.0/go.mod h1:6GjCW8zgDjwGHGa6GkyeB8+/5vjT16gUEi0Nf1iBdgw=
-go.opentelemetry.io/otel/trace v1.2.0/go.mod h1:N5FLswTubnxKxOJHM7XZC074qpeEdLy3CgAVsdMucK0=
-go.opentelemetry.io/otel/trace v1.3.0 h1:doy8Hzb1RJ+I3yFhtDmwNc7tIyw1tNMOIsyPzp1NOGY=
 go.opentelemetry.io/otel/trace v1.3.0/go.mod h1:c/VDhno8888bvQYmbYLqe41/Ldmr/KKunbvWM4/fEjk=
+go.opentelemetry.io/otel/trace v1.4.0 h1:4OOUrPZdVFQkbzl/JSdvGCWIdw5ONXXxzHlaLlWppmo=
+go.opentelemetry.io/otel/trace v1.4.0/go.mod h1:uc3eRsqDfWs9R7b92xbQbU42/eTNz4N+gLP8qJCi4aE=
 go.opentelemetry.io/proto/otlp v0.7.0/go.mod h1:PqfVotwruBrMGOCsRd/89rSnXhoiJIqeYNgFYFoEGnI=
-go.opentelemetry.io/proto/otlp v0.11.0 h1:cLDgIBTf4lLOlztkhzAEdQsJ4Lj+i5Wc9k6Nn0K1VyU=
 go.opentelemetry.io/proto/otlp v0.11.0/go.mod h1:QpEjXPrNQzrFDZgoTo49dgHR9RYRSrg3NAKnUGl9YpQ=
+go.opentelemetry.io/proto/otlp v0.12.0 h1:CMJ/3Wp7iOWES+CYLfnBv+DVmPbB+kmy9PJ92XvlR6c=
+go.opentelemetry.io/proto/otlp v0.12.0/go.mod h1:TsIjwGWIx5VFYv9KGVlOpxoBl5Dy+63SUguV7GGvlSQ=
 go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
--- a/vendor/github.com/google/go-cmp/cmp/compare.go
+++ b/vendor/github.com/google/go-cmp/cmp/compare.go
@ -36,7 +36,6 @@ import (
 	"strings"

 	"github.com/google/go-cmp/cmp/internal/diff"
-	"github.com/google/go-cmp/cmp/internal/flags"
 	"github.com/google/go-cmp/cmp/internal/function"
 	"github.com/google/go-cmp/cmp/internal/value"
 )
@ -319,7 +318,6 @@ func (s *state) tryMethod(t reflect.Type, vx, vy reflect.Value) bool {
 }

 func (s *state) callTRFunc(f, v reflect.Value, step Transform) reflect.Value {
-	v = sanitizeValue(v, f.Type().In(0))
 	if !s.dynChecker.Next() {
 		return f.Call([]reflect.Value{v})[0]
 	}
@ -343,8 +341,6 @@ func (s *state) callTRFunc(f, v reflect.Value, step Transform) reflect.Value {
 }

 func (s *state) callTTBFunc(f, x, y reflect.Value) bool {
-	x = sanitizeValue(x, f.Type().In(0))
-	y = sanitizeValue(y, f.Type().In(1))
 	if !s.dynChecker.Next() {
 		return f.Call([]reflect.Value{x, y})[0].Bool()
 	}
@ -372,19 +368,6 @@ func detectRaces(c chan<- reflect.Value, f reflect.Value, vs ...reflect.Value) {
 	ret = f.Call(vs)[0]
 }

-// sanitizeValue converts nil interfaces of type T to those of type R,
-// assuming that T is assignable to R.
-// Otherwise, it returns the input value as is.
-func sanitizeValue(v reflect.Value, t reflect.Type) reflect.Value {
-	// TODO(≥go1.10): Workaround for reflect bug (https://golang.org/issue/22143).
-	if !flags.AtLeastGo110 {
-		if v.Kind() == reflect.Interface && v.IsNil() && v.Type() != t {
-			return reflect.New(t).Elem()
-		}
-	}
-	return v
-}
-
 func (s *state) compareStruct(t reflect.Type, vx, vy reflect.Value) {
 	var addr bool
 	var vax, vay reflect.Value // Addressable versions of vx and vy
--- a/vendor/github.com/google/go-cmp/cmp/export_panic.go
+++ b/vendor/github.com/google/go-cmp/cmp/export_panic.go
@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

+//go:build purego
 // +build purego

 package cmp
--- a/vendor/github.com/google/go-cmp/cmp/export_unsafe.go
+++ b/vendor/github.com/google/go-cmp/cmp/export_unsafe.go
@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

+//go:build !purego
 // +build !purego

 package cmp
--- a/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_disable.go
@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

+//go:build !cmp_debug
 // +build !cmp_debug

 package diff
--- a/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/diff/debug_enable.go
@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

+//go:build cmp_debug
 // +build cmp_debug

 package diff
--- a/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_legacy.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_legacy.go
@ -1,10 +0,0 @@
-// Copyright 2019, The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.10
-
-package flags
-
-// AtLeastGo110 reports whether the Go toolchain is at least Go 1.10.
-const AtLeastGo110 = false
--- a/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_recent.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/flags/toolchain_recent.go
@ -1,10 +0,0 @@
-// Copyright 2019, The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.10
-
-package flags
-
-// AtLeastGo110 reports whether the Go toolchain is at least Go 1.10.
-const AtLeastGo110 = true
--- a/vendor/github.com/google/go-cmp/cmp/internal/value/name.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/name.go
@ -9,6 +9,8 @@ import (
 	"strconv"
 )

+var anyType = reflect.TypeOf((*interface{})(nil)).Elem()
+
 // TypeString is nearly identical to reflect.Type.String,
 // but has an additional option to specify that full type names be used.
 func TypeString(t reflect.Type, qualified bool) string {
@ -20,6 +22,11 @@ func appendTypeName(b []byte, t reflect.Type, qualified, elideFunc bool) []byte
 	// of the same name and within the same package,
 	// but declared within the namespace of different functions.

+	// Use the "any" alias instead of "interface{}" for better readability.
+	if t == anyType {
+		return append(b, "any"...)
+	}
+
 	// Named type.
 	if t.Name() != "" {
 		if qualified && t.PkgPath() != "" {
--- a/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_purego.go
@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

+//go:build purego
 // +build purego

 package value
--- a/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go
+++ b/vendor/github.com/google/go-cmp/cmp/internal/value/pointer_unsafe.go
@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

+//go:build !purego
 // +build !purego

 package value
--- a/vendor/github.com/google/go-cmp/cmp/path.go
+++ b/vendor/github.com/google/go-cmp/cmp/path.go
@ -178,7 +178,7 @@ type structField struct {
 	unexported bool
 	mayForce   bool                // Forcibly allow visibility
 	paddr      bool                // Was parent addressable?
-	pvx, pvy   reflect.Value       // Parent values (always addressible)
+	pvx, pvy   reflect.Value       // Parent values (always addressable)
 	field      reflect.StructField // Field information
 }

--- a/vendor/github.com/google/go-cmp/cmp/report_reflect.go
+++ b/vendor/github.com/google/go-cmp/cmp/report_reflect.go
@ -207,9 +207,10 @@ func (opts formatOptions) FormatValue(v reflect.Value, parentKind reflect.Kind,
 		// Check whether this is a []byte of text data.
 		if t.Elem() == reflect.TypeOf(byte(0)) {
 			b := v.Bytes()
-			isPrintSpace := func(r rune) bool { return unicode.IsPrint(r) && unicode.IsSpace(r) }
+			isPrintSpace := func(r rune) bool { return unicode.IsPrint(r) || unicode.IsSpace(r) }
 			if len(b) > 0 && utf8.Valid(b) && len(bytes.TrimFunc(b, isPrintSpace)) == 0 {
 				out = opts.formatString("", string(b))
+				skipType = true
 				return opts.WithTypeMode(emitType).FormatType(t, out)
 			}
 		}
--- a/vendor/github.com/google/go-cmp/cmp/report_slices.go
+++ b/vendor/github.com/google/go-cmp/cmp/report_slices.go
@ -80,7 +80,7 @@ func (opts formatOptions) CanFormatDiffSlice(v *valueNode) bool {
 	}

 	// Use specialized string diffing for longer slices or strings.
-	const minLength = 64
+	const minLength = 32
 	return vx.Len() >= minLength && vy.Len() >= minLength
 }

@ -563,10 +563,10 @@ func cleanupSurroundingIdentical(groups []diffStats, eq func(i, j int) bool) []d
 		nx := ds.NumIdentical + ds.NumRemoved + ds.NumModified
 		ny := ds.NumIdentical + ds.NumInserted + ds.NumModified
 		var numLeadingIdentical, numTrailingIdentical int
-		for i := 0; i < nx && i < ny && eq(ix+i, iy+i); i++ {
+		for j := 0; j < nx && j < ny && eq(ix+j, iy+j); j++ {
 			numLeadingIdentical++
 		}
-		for i := 0; i < nx && i < ny && eq(ix+nx-1-i, iy+ny-1-i); i++ {
+		for j := 0; j < nx && j < ny && eq(ix+nx-1-j, iy+ny-1-j); j++ {
 			numTrailingIdentical++
 		}
 		if numIdentical := numLeadingIdentical + numTrailingIdentical; numIdentical > 0 {
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/version.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/version.go
@ -16,7 +16,7 @@ package otelgrpc

 // Version is the current release version of the gRPC instrumentation.
 func Version() string {
-	return "0.27.0"
+	return "0.29.0"
 	// This string is updated by the pre_release.sh script during release
 }

--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace/version.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace/version.go
@ -16,7 +16,7 @@ package otelhttptrace

 // Version is the current release version of the httptrace instrumentation.
 func Version() string {
-	return "0.27.0"
+	return "0.29.0"
 	// This string is updated by the pre_release.sh script during release
 }

--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/transport.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/transport.go
@ -123,18 +123,51 @@ func (t *Transport) RoundTrip(r *http.Request) (*http.Response, error) {

 	span.SetAttributes(semconv.HTTPAttributesFromHTTPStatusCode(res.StatusCode)...)
 	span.SetStatus(semconv.SpanStatusFromHTTPStatusCode(res.StatusCode))
-	res.Body = &wrappedBody{ctx: ctx, span: span, body: res.Body}
+	res.Body = newWrappedBody(span, res.Body)

 	return res, err
 }

+// newWrappedBody returns a new and appropriately scoped *wrappedBody as an
+// io.ReadCloser. If the passed body implements io.Writer, the returned value
+// will implement io.ReadWriteCloser.
+func newWrappedBody(span trace.Span, body io.ReadCloser) io.ReadCloser {
+	// The successful protocol switch responses will have a body that
+	// implement an io.ReadWriteCloser. Ensure this interface type continues
+	// to be satisfied if that is the case.
+	if _, ok := body.(io.ReadWriteCloser); ok {
+		return &wrappedBody{span: span, body: body}
+	}
+
+	// Remove the implementation of the io.ReadWriteCloser and only implement
+	// the io.ReadCloser.
+	return struct{ io.ReadCloser }{&wrappedBody{span: span, body: body}}
+}
+
+// wrappedBody is the response body type returned by the transport
+// instrumentation to complete a span. Errors encountered when using the
+// response body are recorded in span tracking the response.
+//
+// The span tracking the response is ended when this body is closed.
+//
+// If the response body implements the io.Writer interface (i.e. for
+// successful protocol switches), the wrapped body also will.
 type wrappedBody struct {
-	ctx  context.Context
 	span trace.Span
 	body io.ReadCloser
 }

-var _ io.ReadCloser = &wrappedBody{}
+var _ io.ReadWriteCloser = &wrappedBody{}
+
+func (wb *wrappedBody) Write(p []byte) (int, error) {
+	// This will not panic given the guard in newWrappedBody.
+	n, err := wb.body.(io.Writer).Write(p)
+	if err != nil {
+		wb.span.RecordError(err)
+		wb.span.SetStatus(codes.Error, err.Error())
+	}
+	return n, err
+}

 func (wb *wrappedBody) Read(b []byte) (int, error) {
 	n, err := wb.body.Read(b)
--- a/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/version.go
+++ b/vendor/go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp/version.go
@ -16,7 +16,7 @@ package otelhttp

 // Version is the current release version of the otelhttp instrumentation.
 func Version() string {
-	return "0.27.0"
+	return "0.29.0"
 	// This string is updated by the pre_release.sh script during release
 }

--- a/vendor/go.opentelemetry.io/otel/CHANGELOG.md
+++ b/vendor/go.opentelemetry.io/otel/CHANGELOG.md
@ -8,6 +8,50 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm

 ## [Unreleased]

+## [1.4.0] - 2022-02-11
+
+### Added
+
+- Use `OTEL_EXPORTER_ZIPKIN_ENDPOINT` environment variable to specify zipkin collector endpoint. (#2490)
+- Log the configuration of `TracerProvider`s, and `Tracer`s for debugging.
+  To enable use a logger with Verbosity (V level) `>=1`. (#2500)
+- Added support to configure the batch span-processor with environment variables.
+  The following environment variables are used. (#2515)
+  - `OTEL_BSP_SCHEDULE_DELAY`
+  - `OTEL_BSP_EXPORT_TIMEOUT`
+  - `OTEL_BSP_MAX_QUEUE_SIZE`.
+  - `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`
+
+### Changed
+
+- Zipkin exporter exports `Resource` attributes in the `Tags` field. (#2589)
+
+### Deprecated
+
+- Deprecate module the `go.opentelemetry.io/otel/sdk/export/metric`.
+  Use the `go.opentelemetry.io/otel/sdk/metric` module instead. (#2382)
+- Deprecate `"go.opentelemetry.io/otel/sdk/metric".AtomicFieldOffsets`. (#2445)
+
+### Fixed
+
+- Fixed the instrument kind for noop async instruments to correctly report an implementation. (#2461)
+- Fix UDP packets overflowing with Jaeger payloads. (#2489, #2512)
+- Change the `otlpmetric.Client` interface's `UploadMetrics` method to accept a single `ResourceMetrics` instead of a slice of them. (#2491)
+- Specify explicit buckets in Prometheus example, fixing issue where example only has `+inf` bucket. (#2419, #2493)
+- W3C baggage will now decode urlescaped values. (#2529)
+- Baggage members are now only validated once, when calling `NewMember` and not also when adding it to the baggage itself. (#2522)
+- The order attributes are dropped from spans in the `go.opentelemetry.io/otel/sdk/trace` package when capacity is reached is fixed to be in compliance with the OpenTelemetry specification.
+  Instead of dropping the least-recently-used attribute, the last added attribute is dropped.
+  This drop order still only applies to attributes with unique keys not already contained in the span.
+  If an attribute is added with a key already contained in the span, that attribute is updated to the new value being added. (#2576)
+
+### Removed
+
+- Updated `go.opentelemetry.io/proto/otlp` from `v0.11.0` to `v0.12.0`. This version removes a number of deprecated methods. (#2546)
+  - [`Metric.GetIntGauge()`](https://pkg.go.dev/go.opentelemetry.io/proto/otlp@v0.11.0/metrics/v1#Metric.GetIntGauge)
+  - [`Metric.GetIntHistogram()`](https://pkg.go.dev/go.opentelemetry.io/proto/otlp@v0.11.0/metrics/v1#Metric.GetIntHistogram)
+  - [`Metric.GetIntSum()`](https://pkg.go.dev/go.opentelemetry.io/proto/otlp@v0.11.0/metrics/v1#Metric.GetIntSum)
+
 ## [1.3.0] - 2021-12-10

 ### ⚠️ Notice ⚠️
@ -1639,7 +1683,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.3.0...HEAD
+[Unreleased]: https://github.com/open-telemetry/opentelemetry-go/compare/v1.4.0...HEAD
+[1.4.0]: https://github.com/open-telemetry/opentelemetry-go/releases/tag/v1.4.0
 [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
--- a/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md
+++ b/vendor/go.opentelemetry.io/otel/CONTRIBUTING.md
@ -228,11 +228,11 @@ all options to create a configured `config`.

 ```go
 // newConfig returns an appropriately configured config.
-func newConfig([]Option) config {
+func newConfig(options ...Option) config {
 	// Set default values for config.
 	config := config{/* […] */}
 	for _, option := range options {
-		option.apply(&config)
+		config = option.apply(config)
 	}
 	// Preform any validation here.
 	return config
@ -253,7 +253,7 @@ To set the value of the options a `config` contains, a corresponding

 ```go
 type Option interface {
-	apply(*config)
+	apply(config) config
 }
 ```

@ -261,6 +261,9 @@ Having `apply` unexported makes sure that it will not be used externally.
 Moreover, the interface becomes sealed so the user cannot easily implement
 the interface on its own.

+The `apply` method should return a modified version of the passed config.
+This approach, instead of passing a pointer, is used to prevent the config from being allocated to the heap.
+
 The name of the interface should be prefixed in the same way the
 corresponding `config` is (if at all).

@ -283,8 +286,9 @@ func With*(…) Option { … }
 ```go
 type defaultFalseOption bool

-func (o defaultFalseOption) apply(c *config) {
+func (o defaultFalseOption) apply(c config) config {
 	c.Bool = bool(o)
+    return c
 }

 // WithOption sets a T to have an option included.
@ -296,8 +300,9 @@ func WithOption() Option {
 ```go
 type defaultTrueOption bool

-func (o defaultTrueOption) apply(c *config) {
+func (o defaultTrueOption) apply(c config) config {
 	c.Bool = bool(o)
+    return c
 }

 // WithoutOption sets a T to have Bool option excluded.
@ -313,8 +318,9 @@ type myTypeOption struct {
 	MyType MyType
 }

-func (o myTypeOption) apply(c *config) {
+func (o myTypeOption) apply(c config) config {
 	c.MyType = o.MyType
+    return c
 }

 // WithMyType sets T to have include MyType.
@ -326,16 +332,17 @@ func WithMyType(t MyType) Option {
 ##### Functional Options

 ```go
-type optionFunc func(*config)
+type optionFunc func(config) config

-func (fn optionFunc) apply(c *config) {
-	fn(c)
+func (fn optionFunc) apply(c config) config {
+	return fn(c)
 }

 // WithMyType sets t as MyType.
 func WithMyType(t MyType) Option {
-	return optionFunc(func(c *config) {
+	return optionFunc(func(c config) config {
 		c.MyType = t
+        return c
 	})
 }
 ```
@ -370,12 +377,12 @@ type config struct {

 // DogOption apply Dog specific options.
 type DogOption interface {
-	applyDog(*config)
+	applyDog(config) config
 }

 // BirdOption apply Bird specific options.
 type BirdOption interface {
-	applyBird(*config)
+	applyBird(config) config
 }

 // Option apply options for all animals.
@ -385,17 +392,36 @@ type Option interface {
 }

 type weightOption float64
-func (o weightOption) applyDog(c *config)  { c.Weight = float64(o) }
-func (o weightOption) applyBird(c *config) { c.Weight = float64(o) }
-func WithWeight(w float64) Option          { return weightOption(w) }
+
+func (o weightOption) applyDog(c config) config {
+	c.Weight = float64(o)
+	return c
+}
+
+func (o weightOption) applyBird(c config) config {
+	c.Weight = float64(o)
+	return c
+}
+
+func WithWeight(w float64) Option { return weightOption(w) }

 type furColorOption string
-func (o furColorOption) applyDog(c *config) { c.Color = string(o) }
-func WithFurColor(c string) DogOption       { return furColorOption(c) }
+
+func (o furColorOption) applyDog(c config) config {
+	c.Color = string(o)
+	return c
+}
+
+func WithFurColor(c string) DogOption { return furColorOption(c) }

 type maxAltitudeOption float64
-func (o maxAltitudeOption) applyBird(c *config) { c.MaxAltitude = float64(o) }
-func WithMaxAltitude(a float64) BirdOption      { return maxAltitudeOption(a) }
+
+func (o maxAltitudeOption) applyBird(c config) config {
+	c.MaxAltitude = float64(o)
+	return c
+}
+
+func WithMaxAltitude(a float64) BirdOption { return maxAltitudeOption(a) }

 func NewDog(name string, o ...DogOption) Dog    {…}
 func NewBird(name string, o ...BirdOption) Bird {…}
@ -478,7 +504,7 @@ Approvers:

 - [Evan Torrie](https://github.com/evantorrie), Verizon Media
 - [Josh MacDonald](https://github.com/jmacd), LightStep
- [Sam Xie](https://github.com/XSAM)
+- [Sam Xie](https://github.com/XSAM), Cisco/AppDynamics
 - [David Ashpole](https://github.com/dashpole), Google
 - [Gustavo Silva Paiva](https://github.com/paivagustavo), LightStep
 - [Robert Pająk](https://github.com/pellared), Splunk
--- a/vendor/go.opentelemetry.io/otel/RELEASING.md
+++ b/vendor/go.opentelemetry.io/otel/RELEASING.md
@ -108,7 +108,6 @@ It is critical you make sure the version you push upstream is correct.

 Finally create a Release for the new `<new tag>` on GitHub.
 The release body should include all the release notes from the Changelog for this release.
-Additionally, the `tag.sh` script generates commit logs since last release which can be used to supplement the release notes.

 ## Verify Examples

--- a/vendor/go.opentelemetry.io/otel/attribute/kv.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/kv.go
@ -26,7 +26,7 @@ type KeyValue struct {

 // Valid returns if kv is a valid OpenTelemetry attribute.
 func (kv KeyValue) Valid() bool {
-	return kv.Key != "" && kv.Value.Type() != INVALID
+	return kv.Key.Defined() && kv.Value.Type() != INVALID
 }

 // Bool creates a KeyValue with a BOOL Value type.
--- a/vendor/go.opentelemetry.io/otel/attribute/set.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/set.go
@ -410,6 +410,15 @@ func (l *Set) MarshalJSON() ([]byte, error) {
 	return json.Marshal(l.equivalent.iface)
 }

+// MarshalLog is the marshaling function used by the logging system to represent this exporter.
+func (l Set) MarshalLog() interface{} {
+	kvs := make(map[string]string)
+	for _, kv := range l.ToSlice() {
+		kvs[string(kv.Key)] = kv.Value.Emit()
+	}
+	return kvs
+}
+
 // Len implements `sort.Interface`.
 func (l *Sortable) Len() int {
 	return len(*l)
--- a/vendor/go.opentelemetry.io/otel/attribute/value.go
+++ b/vendor/go.opentelemetry.io/otel/attribute/value.go
@ -187,7 +187,7 @@ func (v Value) AsFloat64() float64 {
 }

 // AsFloat64Slice returns the []float64 value. Make sure that the Value's type is
-// INT64SLICE.
+// FLOAT64SLICE.
 func (v Value) AsFloat64Slice() []float64 {
 	if s, ok := v.slice.(*[]float64); ok {
 		return *s
@ -202,7 +202,7 @@ func (v Value) AsString() string {
 }

 // AsStringSlice returns the []string value. Make sure that the Value's type is
-// INT64SLICE.
+// STRINGSLICE.
 func (v Value) AsStringSlice() []string {
 	if s, ok := v.slice.(*[]string); ok {
 		return *s
--- a/vendor/go.opentelemetry.io/otel/baggage/baggage.go
+++ b/vendor/go.opentelemetry.io/otel/baggage/baggage.go
@ -61,45 +61,57 @@ type Property struct {
 	// hasValue indicates if a zero-value value means the property does not
 	// have a value or if it was the zero-value.
 	hasValue bool
+
+	// hasData indicates whether the created property contains data or not.
+	// Properties that do not contain data are invalid with no other check
+	// required.
+	hasData bool
 }

 func NewKeyProperty(key string) (Property, error) {
-	p := Property{}
 	if !keyRe.MatchString(key) {
-		return p, fmt.Errorf("%w: %q", errInvalidKey, key)
+		return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidKey, key)
 	}
-	p.key = key
+
+	p := Property{key: key, hasData: true}
 	return p, nil
 }

 func NewKeyValueProperty(key, value string) (Property, error) {
-	p := Property{}
 	if !keyRe.MatchString(key) {
-		return p, fmt.Errorf("%w: %q", errInvalidKey, key)
+		return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidKey, key)
 	}
 	if !valueRe.MatchString(value) {
-		return p, fmt.Errorf("%w: %q", errInvalidValue, value)
+		return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidValue, value)
+	}
+
+	p := Property{
+		key:      key,
+		value:    value,
+		hasValue: true,
+		hasData:  true,
 	}
-	p.key = key
-	p.value = value
-	p.hasValue = true
 	return p, nil
 }

+func newInvalidProperty() Property {
+	return Property{}
+}
+
 // parseProperty attempts to decode a Property from the passed string. It
 // returns an error if the input is invalid according to the W3C Baggage
 // specification.
 func parseProperty(property string) (Property, error) {
-	p := Property{}
 	if property == "" {
-		return p, nil
+		return newInvalidProperty(), nil
 	}

 	match := propertyRe.FindStringSubmatch(property)
 	if len(match) != 4 {
-		return p, fmt.Errorf("%w: %q", errInvalidProperty, property)
+		return newInvalidProperty(), fmt.Errorf("%w: %q", errInvalidProperty, property)
 	}

+	p := Property{hasData: true}
 	if match[1] != "" {
 		p.key = match[1]
 	} else {
@ -107,6 +119,7 @@ func parseProperty(property string) (Property, error) {
 		p.value = match[3]
 		p.hasValue = true
 	}
+
 	return p, nil
 }

@ -117,6 +130,10 @@ func (p Property) validate() error {
 		return fmt.Errorf("invalid property: %w", err)
 	}

+	if !p.hasData {
+		return errFunc(fmt.Errorf("%w: %q", errInvalidProperty, p))
+	}
+
 	if !keyRe.MatchString(p.key) {
 		return errFunc(fmt.Errorf("%w: %q", errInvalidKey, p.key))
 	}
@ -220,26 +237,40 @@ func (p properties) String() string {
 type Member struct {
 	key, value string
 	properties properties
+
+	// hasData indicates whether the created property contains data or not.
+	// Properties that do not contain data are invalid with no other check
+	// required.
+	hasData bool
 }

 // NewMember returns a new Member from the passed arguments. An error is
 // returned if the created Member would be invalid according to the W3C
 // Baggage specification.
 func NewMember(key, value string, props ...Property) (Member, error) {
-	m := Member{key: key, value: value, properties: properties(props).Copy()}
+	m := Member{
+		key:        key,
+		value:      value,
+		properties: properties(props).Copy(),
+		hasData:    true,
+	}
 	if err := m.validate(); err != nil {
-		return Member{}, err
+		return newInvalidMember(), err
 	}

 	return m, nil
 }

+func newInvalidMember() Member {
+	return Member{}
+}
+
 // parseMember attempts to decode a Member from the passed string. It returns
 // an error if the input is invalid according to the W3C Baggage
 // specification.
 func parseMember(member string) (Member, error) {
 	if n := len(member); n > maxBytesPerMembers {
-		return Member{}, fmt.Errorf("%w: %d", errMemberBytes, n)
+		return newInvalidMember(), fmt.Errorf("%w: %d", errMemberBytes, n)
 	}

 	var (
@ -254,7 +285,7 @@ func parseMember(member string) (Member, error) {
 		for _, pStr := range strings.Split(parts[1], propertyDelimiter) {
 			p, err := parseProperty(pStr)
 			if err != nil {
-				return Member{}, err
+				return newInvalidMember(), err
 			}
 			props = append(props, p)
 		}
@ -265,16 +296,21 @@ func parseMember(member string) (Member, error) {
 		// Take into account a value can contain equal signs (=).
 		kv := strings.SplitN(parts[0], keyValueDelimiter, 2)
 		if len(kv) != 2 {
-			return Member{}, fmt.Errorf("%w: %q", errInvalidMember, member)
+			return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidMember, member)
 		}
 		// "Leading and trailing whitespaces are allowed but MUST be trimmed
 		// when converting the header into a data structure."
-		key, value = strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1])
+		key = strings.TrimSpace(kv[0])
+		var err error
+		value, err = url.QueryUnescape(strings.TrimSpace(kv[1]))
+		if err != nil {
+			return newInvalidMember(), fmt.Errorf("%w: %q", err, value)
+		}
 		if !keyRe.MatchString(key) {
-			return Member{}, fmt.Errorf("%w: %q", errInvalidKey, key)
+			return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidKey, key)
 		}
 		if !valueRe.MatchString(value) {
-			return Member{}, fmt.Errorf("%w: %q", errInvalidValue, value)
+			return newInvalidMember(), fmt.Errorf("%w: %q", errInvalidValue, value)
 		}
 	default:
 		// This should never happen unless a developer has changed the string
@ -283,12 +319,16 @@ func parseMember(member string) (Member, error) {
 		panic("failed to parse baggage member")
 	}

-	return Member{key: key, value: value, properties: props}, nil
+	return Member{key: key, value: value, properties: props, hasData: true}, nil
 }

 // validate ensures m conforms to the W3C Baggage specification, returning an
 // error otherwise.
 func (m Member) validate() error {
+	if !m.hasData {
+		return fmt.Errorf("%w: %q", errInvalidMember, m)
+	}
+
 	if !keyRe.MatchString(m.key) {
 		return fmt.Errorf("%w: %q", errInvalidKey, m.key)
 	}
@ -324,9 +364,10 @@ type Baggage struct { //nolint:golint
 	list baggage.List
 }

-// New returns a new valid Baggage. It returns an error if the passed members
-// are invalid according to the W3C Baggage specification or if it results in
-// a Baggage exceeding limits set in that specification.
+// New returns a new valid Baggage. It returns an error if it results in a
+// Baggage exceeding limits set in that specification.
+//
+// It expects all the provided members to have already been validated.
 func New(members ...Member) (Baggage, error) {
 	if len(members) == 0 {
 		return Baggage{}, nil
@ -334,9 +375,10 @@ func New(members ...Member) (Baggage, error) {

 	b := make(baggage.List)
 	for _, m := range members {
-		if err := m.validate(); err != nil {
-			return Baggage{}, err
+		if !m.hasData {
+			return Baggage{}, errInvalidMember
 		}
+
 		// OpenTelemetry resolves duplicates by last-one-wins.
 		b[m.key] = baggage.Item{
 			Value:      m.value,
@ -401,6 +443,8 @@ func Parse(bStr string) (Baggage, error) {
 //
 // If there is no list-member matching the passed key the returned Member will
 // be a zero-value Member.
+// The returned member is not validated, as we assume the validation happened
+// when it was added to the Baggage.
 func (b Baggage) Member(key string) Member {
 	v, ok := b.list[key]
 	if !ok {
@ -408,7 +452,7 @@ func (b Baggage) Member(key string) Member {
 		// where a zero-valued Member is included in the Baggage because a
 		// zero-valued Member is invalid according to the W3C Baggage
 		// specification (it has an empty key).
-		return Member{}
+		return newInvalidMember()
 	}

 	return Member{
@ -420,6 +464,9 @@ func (b Baggage) Member(key string) Member {

 // Members returns all the baggage list-members.
 // The order of the returned list-members does not have significance.
+//
+// The returned members are not validated, as we assume the validation happened
+// when they were added to the Baggage.
 func (b Baggage) Members() []Member {
 	if len(b.list) == 0 {
 		return nil
@ -443,8 +490,8 @@ func (b Baggage) Members() []Member {
 // If member is invalid according to the W3C Baggage specification, an error
 // is returned with the original Baggage.
 func (b Baggage) SetMember(member Member) (Baggage, error) {
-	if err := member.validate(); err != nil {
-		return b, fmt.Errorf("%w: %s", errInvalidMember, err)
+	if !member.hasData {
+		return b, errInvalidMember
 	}

 	n := len(b.list)
--- a/vendor/go.opentelemetry.io/otel/exporters/jaeger/agent.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/jaeger/agent.go
@ -28,8 +28,13 @@ import (
 	"go.opentelemetry.io/otel/exporters/jaeger/internal/third_party/thrift/lib/go/thrift"
 )

-// udpPacketMaxLength is the max size of UDP packet we want to send, synced with jaeger-agent
-const udpPacketMaxLength = 65000
+const (
+	// udpPacketMaxLength is the max size of UDP packet we want to send, synced with jaeger-agent
+	udpPacketMaxLength = 65000
+	// emitBatchOverhead is the additional overhead bytes used for enveloping the datagram,
+	// synced with jaeger-agent https://github.com/jaegertracing/jaeger-client-go/blob/master/transport_udp.go#L37
+	emitBatchOverhead = 70
+)

 // agentClientUDP is a UDP client to Jaeger agent that implements gen.Agent interface.
 type agentClientUDP struct {
@ -66,7 +71,7 @@ func newAgentClientUDP(params agentClientUDPParams) (*agentClientUDP, error) {
 		return nil, err
 	}

-	if params.MaxPacketSize <= 0 {
+	if params.MaxPacketSize <= 0 || params.MaxPacketSize > udpPacketMaxLength {
 		params.MaxPacketSize = udpPacketMaxLength
 	}

@ -121,6 +126,11 @@ func (a *agentClientUDP) EmitBatch(ctx context.Context, batch *gen.Batch) error
 		// drop the batch if serialization of process fails.
 		return err
 	}
+
+	maxPacketSize := a.maxPacketSize
+	if maxPacketSize > udpPacketMaxLength-emitBatchOverhead {
+		maxPacketSize = udpPacketMaxLength - emitBatchOverhead
+	}
 	totalSize := processSize
 	var spans []*gen.Span
 	for _, span := range batch.Spans {
@ -129,12 +139,12 @@ func (a *agentClientUDP) EmitBatch(ctx context.Context, batch *gen.Batch) error
 			errs = append(errs, fmt.Errorf("thrift serialization failed: %v", span))
 			continue
 		}
-		if spanSize+processSize >= a.maxPacketSize {
+		if spanSize+processSize >= maxPacketSize {
 			// drop the span that exceeds the limit.
 			errs = append(errs, fmt.Errorf("span too large to send: %v", span))
 			continue
 		}
-		if totalSize+spanSize >= a.maxPacketSize {
+		if totalSize+spanSize >= maxPacketSize {
 			if err := a.flush(ctx, &gen.Batch{
 				Process: batch.Process,
 				Spans:   spans,
--- a/vendor/go.opentelemetry.io/otel/exporters/jaeger/uploader.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/jaeger/uploader.go
@ -55,7 +55,7 @@ func (fn endpointOptionFunc) newBatchUploader() (batchUploader, error) {
 // will be used if neither are provided.
 func WithAgentEndpoint(options ...AgentEndpointOption) EndpointOption {
 	return endpointOptionFunc(func() (batchUploader, error) {
-		cfg := &agentEndpointConfig{
+		cfg := agentEndpointConfig{
 			agentClientUDPParams{
 				AttemptReconnecting: true,
 				Host:                envOr(envAgentHost, "localhost"),
@ -63,7 +63,7 @@ func WithAgentEndpoint(options ...AgentEndpointOption) EndpointOption {
 			},
 		}
 		for _, opt := range options {
-			opt.apply(cfg)
+			cfg = opt.apply(cfg)
 		}

 		client, err := newAgentClientUDP(cfg.agentClientUDPParams)
@ -76,17 +76,17 @@ func WithAgentEndpoint(options ...AgentEndpointOption) EndpointOption {
 }

 type AgentEndpointOption interface {
-	apply(*agentEndpointConfig)
+	apply(agentEndpointConfig) agentEndpointConfig
 }

 type agentEndpointConfig struct {
 	agentClientUDPParams
 }

-type agentEndpointOptionFunc func(*agentEndpointConfig)
+type agentEndpointOptionFunc func(agentEndpointConfig) agentEndpointConfig

-func (fn agentEndpointOptionFunc) apply(cfg *agentEndpointConfig) {
-	fn(cfg)
+func (fn agentEndpointOptionFunc) apply(cfg agentEndpointConfig) agentEndpointConfig {
+	return fn(cfg)
 }

 // WithAgentHost sets a host to be used in the agent client endpoint.
@ -94,8 +94,9 @@ func (fn agentEndpointOptionFunc) apply(cfg *agentEndpointConfig) {
 // OTEL_EXPORTER_JAEGER_AGENT_HOST environment variable.
 // If this option is not passed and the env var is not set, "localhost" will be used by default.
 func WithAgentHost(host string) AgentEndpointOption {
-	return agentEndpointOptionFunc(func(o *agentEndpointConfig) {
+	return agentEndpointOptionFunc(func(o agentEndpointConfig) agentEndpointConfig {
 		o.Host = host
+		return o
 	})
 }

@ -104,36 +105,41 @@ func WithAgentHost(host string) AgentEndpointOption {
 // OTEL_EXPORTER_JAEGER_AGENT_PORT environment variable.
 // If this option is not passed and the env var is not set, "6831" will be used by default.
 func WithAgentPort(port string) AgentEndpointOption {
-	return agentEndpointOptionFunc(func(o *agentEndpointConfig) {
+	return agentEndpointOptionFunc(func(o agentEndpointConfig) agentEndpointConfig {
 		o.Port = port
+		return o
 	})
 }

 // WithLogger sets a logger to be used by agent client.
 func WithLogger(logger *log.Logger) AgentEndpointOption {
-	return agentEndpointOptionFunc(func(o *agentEndpointConfig) {
+	return agentEndpointOptionFunc(func(o agentEndpointConfig) agentEndpointConfig {
 		o.Logger = logger
+		return o
 	})
 }

 // WithDisableAttemptReconnecting sets option to disable reconnecting udp client.
 func WithDisableAttemptReconnecting() AgentEndpointOption {
-	return agentEndpointOptionFunc(func(o *agentEndpointConfig) {
+	return agentEndpointOptionFunc(func(o agentEndpointConfig) agentEndpointConfig {
 		o.AttemptReconnecting = false
+		return o
 	})
 }

 // WithAttemptReconnectingInterval sets the interval between attempts to re resolve agent endpoint.
 func WithAttemptReconnectingInterval(interval time.Duration) AgentEndpointOption {
-	return agentEndpointOptionFunc(func(o *agentEndpointConfig) {
+	return agentEndpointOptionFunc(func(o agentEndpointConfig) agentEndpointConfig {
 		o.AttemptReconnectInterval = interval
+		return o
 	})
 }

 // WithMaxPacketSize sets the maximum UDP packet size for transport to the Jaeger agent.
 func WithMaxPacketSize(size int) AgentEndpointOption {
-	return agentEndpointOptionFunc(func(o *agentEndpointConfig) {
+	return agentEndpointOptionFunc(func(o agentEndpointConfig) agentEndpointConfig {
 		o.MaxPacketSize = size
+		return o
 	})
 }

@ -149,7 +155,7 @@ func WithMaxPacketSize(size int) AgentEndpointOption {
 // If neither values are provided for the username or the password, they will not be set since there is no default.
 func WithCollectorEndpoint(options ...CollectorEndpointOption) EndpointOption {
 	return endpointOptionFunc(func() (batchUploader, error) {
-		cfg := &collectorEndpointConfig{
+		cfg := collectorEndpointConfig{
 			endpoint:   envOr(envEndpoint, "http://localhost:14268/api/traces"),
 			username:   envOr(envUser, ""),
 			password:   envOr(envPassword, ""),
@ -157,7 +163,7 @@ func WithCollectorEndpoint(options ...CollectorEndpointOption) EndpointOption {
 		}

 		for _, opt := range options {
-			opt.apply(cfg)
+			cfg = opt.apply(cfg)
 		}

 		return &collectorUploader{
@ -170,7 +176,7 @@ func WithCollectorEndpoint(options ...CollectorEndpointOption) EndpointOption {
 }

 type CollectorEndpointOption interface {
-	apply(*collectorEndpointConfig)
+	apply(collectorEndpointConfig) collectorEndpointConfig
 }

 type collectorEndpointConfig struct {
@ -187,10 +193,10 @@ type collectorEndpointConfig struct {
 	httpClient *http.Client
 }

-type collectorEndpointOptionFunc func(*collectorEndpointConfig)
+type collectorEndpointOptionFunc func(collectorEndpointConfig) collectorEndpointConfig

-func (fn collectorEndpointOptionFunc) apply(cfg *collectorEndpointConfig) {
-	fn(cfg)
+func (fn collectorEndpointOptionFunc) apply(cfg collectorEndpointConfig) collectorEndpointConfig {
+	return fn(cfg)
 }

 // WithEndpoint is the URL for the Jaeger collector that spans are sent to.
@ -199,8 +205,9 @@ func (fn collectorEndpointOptionFunc) apply(cfg *collectorEndpointConfig) {
 // If this option is not passed and the environment variable is not set,
 // "http://localhost:14268/api/traces" will be used by default.
 func WithEndpoint(endpoint string) CollectorEndpointOption {
-	return collectorEndpointOptionFunc(func(o *collectorEndpointConfig) {
+	return collectorEndpointOptionFunc(func(o collectorEndpointConfig) collectorEndpointConfig {
 		o.endpoint = endpoint
+		return o
 	})
 }

@ -209,8 +216,9 @@ func WithEndpoint(endpoint string) CollectorEndpointOption {
 // OTEL_EXPORTER_JAEGER_USER environment variable.
 // If this option is not passed and the environment variable is not set, no username will be set.
 func WithUsername(username string) CollectorEndpointOption {
-	return collectorEndpointOptionFunc(func(o *collectorEndpointConfig) {
+	return collectorEndpointOptionFunc(func(o collectorEndpointConfig) collectorEndpointConfig {
 		o.username = username
+		return o
 	})
 }

@ -219,15 +227,17 @@ func WithUsername(username string) CollectorEndpointOption {
 // OTEL_EXPORTER_JAEGER_PASSWORD environment variable.
 // If this option is not passed and the environment variable is not set, no password will be set.
 func WithPassword(password string) CollectorEndpointOption {
-	return collectorEndpointOptionFunc(func(o *collectorEndpointConfig) {
+	return collectorEndpointOptionFunc(func(o collectorEndpointConfig) collectorEndpointConfig {
 		o.password = password
+		return o
 	})
 }

 // WithHTTPClient sets the http client to be used to make request to the collector endpoint.
 func WithHTTPClient(client *http.Client) CollectorEndpointOption {
-	return collectorEndpointOptionFunc(func(o *collectorEndpointConfig) {
+	return collectorEndpointOptionFunc(func(o collectorEndpointConfig) collectorEndpointConfig {
 		o.httpClient = client
+		return o
 	})
 }

--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig/envconfig.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig/envconfig.go
@ -33,12 +33,12 @@ var DefaultEnvOptionsReader = EnvOptionsReader{
 	ReadFile: ioutil.ReadFile,
 }

-func ApplyGRPCEnvConfigs(cfg *Config) {
-	DefaultEnvOptionsReader.ApplyGRPCEnvConfigs(cfg)
+func ApplyGRPCEnvConfigs(cfg Config) Config {
+	return DefaultEnvOptionsReader.ApplyGRPCEnvConfigs(cfg)
 }

-func ApplyHTTPEnvConfigs(cfg *Config) {
-	DefaultEnvOptionsReader.ApplyHTTPEnvConfigs(cfg)
+func ApplyHTTPEnvConfigs(cfg Config) Config {
+	return DefaultEnvOptionsReader.ApplyHTTPEnvConfigs(cfg)
 }

 type EnvOptionsReader struct {
@ -46,18 +46,20 @@ type EnvOptionsReader struct {
 	ReadFile func(filename string) ([]byte, error)
 }

-func (e *EnvOptionsReader) ApplyHTTPEnvConfigs(cfg *Config) {
+func (e *EnvOptionsReader) ApplyHTTPEnvConfigs(cfg Config) Config {
 	opts := e.GetOptionsFromEnv()
 	for _, opt := range opts {
-		opt.ApplyHTTPOption(cfg)
+		cfg = opt.ApplyHTTPOption(cfg)
 	}
+	return cfg
 }

-func (e *EnvOptionsReader) ApplyGRPCEnvConfigs(cfg *Config) {
+func (e *EnvOptionsReader) ApplyGRPCEnvConfigs(cfg Config) Config {
 	opts := e.GetOptionsFromEnv()
 	for _, opt := range opts {
-		opt.ApplyGRPCOption(cfg)
+		cfg = opt.ApplyGRPCOption(cfg)
 	}
+	return cfg
 }

 func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
@ -74,7 +76,7 @@ func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
 			} else {
 				opts = append(opts, WithSecure())
 			}
-			opts = append(opts, newSplitOption(func(cfg *Config) {
+			opts = append(opts, newSplitOption(func(cfg Config) Config {
 				cfg.Traces.Endpoint = u.Host
 				// For endpoint URLs for OTLP/HTTP per-signal variables, the
 				// URL MUST be used as-is without any modification. The only
@ -85,10 +87,12 @@ func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
 					path = "/"
 				}
 				cfg.Traces.URLPath = path
-			}, func(cfg *Config) {
+				return cfg
+			}, func(cfg Config) Config {
 				// For OTLP/gRPC endpoints, this is the target to which the
 				// exporter is going to send telemetry.
 				cfg.Traces.Endpoint = path.Join(u.Host, u.Path)
+				return cfg
 			}))
 		}
 	} else if v, ok = e.getEnvValue("ENDPOINT"); ok {
@ -101,16 +105,18 @@ func (e *EnvOptionsReader) GetOptionsFromEnv() []GenericOption {
 			} else {
 				opts = append(opts, WithSecure())
 			}
-			opts = append(opts, newSplitOption(func(cfg *Config) {
+			opts = append(opts, newSplitOption(func(cfg Config) Config {
 				cfg.Traces.Endpoint = u.Host
 				// For OTLP/HTTP endpoint URLs without a per-signal
 				// configuration, the passed endpoint is used as a base URL
 				// and the signals are sent to these paths relative to that.
 				cfg.Traces.URLPath = path.Join(u.Path, DefaultTracesPath)
-			}, func(cfg *Config) {
+				return cfg
+			}, func(cfg Config) Config {
 				// For OTLP/gRPC endpoints, this is the target to which the
 				// exporter is going to send telemetry.
 				cfg.Traces.Endpoint = path.Join(u.Host, u.Path)
+				return cfg
 			}))
 		}
 	}
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig/options.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig/options.go
@ -22,6 +22,7 @@ import (
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/backoff"
 	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/credentials/insecure"
 	"google.golang.org/grpc/encoding/gzip"

 	"go.opentelemetry.io/otel/exporters/otlp/internal/retry"
@ -82,9 +83,9 @@ func NewDefaultConfig() Config {
 // any unset setting using the default gRPC config values.
 func NewGRPCConfig(opts ...GRPCOption) Config {
 	cfg := NewDefaultConfig()
-	ApplyGRPCEnvConfigs(&cfg)
+	cfg = ApplyGRPCEnvConfigs(cfg)
 	for _, opt := range opts {
-		opt.ApplyGRPCOption(&cfg)
+		cfg = opt.ApplyGRPCOption(cfg)
 	}

 	if cfg.ServiceConfig != "" {
@ -94,7 +95,7 @@ func NewGRPCConfig(opts ...GRPCOption) Config {
 	if cfg.Traces.GRPCCredentials != nil {
 		cfg.DialOptions = append(cfg.DialOptions, grpc.WithTransportCredentials(cfg.Traces.GRPCCredentials))
 	} else if cfg.Traces.Insecure {
-		cfg.DialOptions = append(cfg.DialOptions, grpc.WithInsecure())
+		cfg.DialOptions = append(cfg.DialOptions, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	} else {
 		// Default to using the host's root CA.
 		creds := credentials.NewTLS(nil)
@ -121,8 +122,8 @@ func NewGRPCConfig(opts ...GRPCOption) Config {
 type (
 	// GenericOption applies an option to the HTTP or gRPC driver.
 	GenericOption interface {
-		ApplyHTTPOption(*Config)
-		ApplyGRPCOption(*Config)
+		ApplyHTTPOption(Config) Config
+		ApplyGRPCOption(Config) Config

 		// A private method to prevent users implementing the
 		// interface and so future additions to it will not
@ -132,7 +133,7 @@ type (

 	// HTTPOption applies an option to the HTTP driver.
 	HTTPOption interface {
-		ApplyHTTPOption(*Config)
+		ApplyHTTPOption(Config) Config

 		// A private method to prevent users implementing the
 		// interface and so future additions to it will not
@ -142,7 +143,7 @@ type (

 	// GRPCOption applies an option to the gRPC driver.
 	GRPCOption interface {
-		ApplyGRPCOption(*Config)
+		ApplyGRPCOption(Config) Config

 		// A private method to prevent users implementing the
 		// interface and so future additions to it will not
@ -154,128 +155,138 @@ type (
 // genericOption is an option that applies the same logic
 // for both gRPC and HTTP.
 type genericOption struct {
-	fn func(*Config)
+	fn func(Config) Config
 }

-func (g *genericOption) ApplyGRPCOption(cfg *Config) {
-	g.fn(cfg)
+func (g *genericOption) ApplyGRPCOption(cfg Config) Config {
+	return g.fn(cfg)
 }

-func (g *genericOption) ApplyHTTPOption(cfg *Config) {
-	g.fn(cfg)
+func (g *genericOption) ApplyHTTPOption(cfg Config) Config {
+	return g.fn(cfg)
 }

 func (genericOption) private() {}

-func newGenericOption(fn func(cfg *Config)) GenericOption {
+func newGenericOption(fn func(cfg Config) Config) GenericOption {
 	return &genericOption{fn: fn}
 }

 // splitOption is an option that applies different logics
 // for gRPC and HTTP.
 type splitOption struct {
-	httpFn func(*Config)
-	grpcFn func(*Config)
+	httpFn func(Config) Config
+	grpcFn func(Config) Config
 }

-func (g *splitOption) ApplyGRPCOption(cfg *Config) {
-	g.grpcFn(cfg)
+func (g *splitOption) ApplyGRPCOption(cfg Config) Config {
+	return g.grpcFn(cfg)
 }

-func (g *splitOption) ApplyHTTPOption(cfg *Config) {
-	g.httpFn(cfg)
+func (g *splitOption) ApplyHTTPOption(cfg Config) Config {
+	return g.httpFn(cfg)
 }

 func (splitOption) private() {}

-func newSplitOption(httpFn func(cfg *Config), grpcFn func(cfg *Config)) GenericOption {
+func newSplitOption(httpFn func(cfg Config) Config, grpcFn func(cfg Config) Config) GenericOption {
 	return &splitOption{httpFn: httpFn, grpcFn: grpcFn}
 }

 // httpOption is an option that is only applied to the HTTP driver.
 type httpOption struct {
-	fn func(*Config)
+	fn func(Config) Config
 }

-func (h *httpOption) ApplyHTTPOption(cfg *Config) {
-	h.fn(cfg)
+func (h *httpOption) ApplyHTTPOption(cfg Config) Config {
+	return h.fn(cfg)
 }

 func (httpOption) private() {}

-func NewHTTPOption(fn func(cfg *Config)) HTTPOption {
+func NewHTTPOption(fn func(cfg Config) Config) HTTPOption {
 	return &httpOption{fn: fn}
 }

 // grpcOption is an option that is only applied to the gRPC driver.
 type grpcOption struct {
-	fn func(*Config)
+	fn func(Config) Config
 }

-func (h *grpcOption) ApplyGRPCOption(cfg *Config) {
-	h.fn(cfg)
+func (h *grpcOption) ApplyGRPCOption(cfg Config) Config {
+	return h.fn(cfg)
 }

 func (grpcOption) private() {}

-func NewGRPCOption(fn func(cfg *Config)) GRPCOption {
+func NewGRPCOption(fn func(cfg Config) Config) GRPCOption {
 	return &grpcOption{fn: fn}
 }

 // Generic Options

 func WithEndpoint(endpoint string) GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.Endpoint = endpoint
+		return cfg
 	})
 }

 func WithCompression(compression Compression) GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.Compression = compression
+		return cfg
 	})
 }

 func WithURLPath(urlPath string) GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.URLPath = urlPath
+		return cfg
 	})
 }

 func WithRetry(rc retry.Config) GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.RetryConfig = rc
+		return cfg
 	})
 }

 func WithTLSClientConfig(tlsCfg *tls.Config) GenericOption {
-	return newSplitOption(func(cfg *Config) {
+	return newSplitOption(func(cfg Config) Config {
 		cfg.Traces.TLSCfg = tlsCfg.Clone()
-	}, func(cfg *Config) {
+		return cfg
+	}, func(cfg Config) Config {
 		cfg.Traces.GRPCCredentials = credentials.NewTLS(tlsCfg)
+		return cfg
 	})
 }

 func WithInsecure() GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.Insecure = true
+		return cfg
 	})
 }

 func WithSecure() GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.Insecure = false
+		return cfg
 	})
 }

 func WithHeaders(headers map[string]string) GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.Headers = headers
+		return cfg
 	})
 }

 func WithTimeout(duration time.Duration) GenericOption {
-	return newGenericOption(func(cfg *Config) {
+	return newGenericOption(func(cfg Config) Config {
 		cfg.Traces.Timeout = duration
+		return cfg
 	})
 }
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/options.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc/options.go
@ -28,7 +28,7 @@ import (

 // Option applies an option to the gRPC driver.
 type Option interface {
-	applyGRPCOption(*otlpconfig.Config)
+	applyGRPCOption(otlpconfig.Config) otlpconfig.Config
 }

 func asGRPCOptions(opts []Option) []otlpconfig.GRPCOption {
@ -50,8 +50,8 @@ type wrappedOption struct {
 	otlpconfig.GRPCOption
 }

-func (w wrappedOption) applyGRPCOption(cfg *otlpconfig.Config) {
-	w.ApplyGRPCOption(cfg)
+func (w wrappedOption) applyGRPCOption(cfg otlpconfig.Config) otlpconfig.Config {
+	return w.ApplyGRPCOption(cfg)
 }

 // WithInsecure disables client transport security for the exporter's gRPC
@ -77,8 +77,9 @@ func WithEndpoint(endpoint string) Option {
 //
 // This option has no effect if WithGRPCConn is used.
 func WithReconnectionPeriod(rp time.Duration) Option {
-	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg *otlpconfig.Config) {
+	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg otlpconfig.Config) otlpconfig.Config {
 		cfg.ReconnectionPeriod = rp
+		return cfg
 	})}
 }

@ -117,8 +118,9 @@ func WithHeaders(headers map[string]string) Option {
 //
 // This option has no effect if WithGRPCConn is used.
 func WithTLSCredentials(creds credentials.TransportCredentials) Option {
-	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg *otlpconfig.Config) {
+	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg otlpconfig.Config) otlpconfig.Config {
 		cfg.Traces.GRPCCredentials = creds
+		return cfg
 	})}
 }

@ -126,8 +128,9 @@ func WithTLSCredentials(creds credentials.TransportCredentials) Option {
 //
 // This option has no effect if WithGRPCConn is used.
 func WithServiceConfig(serviceConfig string) Option {
-	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg *otlpconfig.Config) {
+	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg otlpconfig.Config) otlpconfig.Config {
 		cfg.ServiceConfig = serviceConfig
+		return cfg
 	})}
 }

@ -138,8 +141,9 @@ func WithServiceConfig(serviceConfig string) Option {
 //
 // This option has no effect if WithGRPCConn is used.
 func WithDialOption(opts ...grpc.DialOption) Option {
-	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg *otlpconfig.Config) {
+	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg otlpconfig.Config) otlpconfig.Config {
 		cfg.DialOptions = opts
+		return cfg
 	})}
 }

@ -152,8 +156,9 @@ func WithDialOption(opts ...grpc.DialOption) Option {
 // It is the callers responsibility to close the passed conn. The client
 // Shutdown method will not close this connection.
 func WithGRPCConn(conn *grpc.ClientConn) Option {
-	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg *otlpconfig.Config) {
+	return wrappedOption{otlpconfig.NewGRPCOption(func(cfg otlpconfig.Config) otlpconfig.Config {
 		cfg.GRPCConn = conn
+		return cfg
 	})}
 }

--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/client.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/client.go
@ -80,9 +80,9 @@ var _ otlptrace.Client = (*client)(nil)
 // NewClient creates a new HTTP trace client.
 func NewClient(opts ...Option) otlptrace.Client {
 	cfg := otlpconfig.NewDefaultConfig()
-	otlpconfig.ApplyHTTPEnvConfigs(&cfg)
+	cfg = otlpconfig.ApplyHTTPEnvConfigs(cfg)
 	for _, opt := range opts {
-		opt.applyHTTPOption(&cfg)
+		cfg = opt.applyHTTPOption(cfg)
 	}

 	for pathPtr, defaultPath := range map[*string]string{
--- a/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/options.go
+++ b/vendor/go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp/options.go
@ -37,7 +37,7 @@ const (

 // Option applies an option to the HTTP client.
 type Option interface {
-	applyHTTPOption(*otlpconfig.Config)
+	applyHTTPOption(otlpconfig.Config) otlpconfig.Config
 }

 // RetryConfig defines configuration for retrying batches in case of export
@ -48,8 +48,8 @@ type wrappedOption struct {
 	otlpconfig.HTTPOption
 }

-func (w wrappedOption) applyHTTPOption(cfg *otlpconfig.Config) {
-	w.ApplyHTTPOption(cfg)
+func (w wrappedOption) applyHTTPOption(cfg otlpconfig.Config) otlpconfig.Config {
+	return w.ApplyHTTPOption(cfg)
 }

 // WithEndpoint allows one to set the address of the collector
--- a/vendor/go.opentelemetry.io/otel/internal/metric/global/meter.go
+++ b/vendor/go.opentelemetry.io/otel/internal/metric/global/meter.go
@ -92,18 +92,6 @@ type asyncImpl struct {
 	runner sdkapi.AsyncRunner
 }

-// SyncImpler is implemented by all of the sync metric
-// instruments.
-type SyncImpler interface {
-	SyncImpl() sdkapi.SyncImpl
-}
-
-// AsyncImpler is implemented by all of the async
-// metric instruments.
-type AsyncImpler interface {
-	AsyncImpl() sdkapi.AsyncImpl
-}
-
 var _ metric.MeterProvider = &meterProvider{}
 var _ sdkapi.MeterImpl = &meterImpl{}
 var _ sdkapi.InstrumentImpl = &syncImpl{}
--- a/vendor/go.opentelemetry.io/otel/metric/config.go
+++ b/vendor/go.opentelemetry.io/otel/metric/config.go
@ -25,12 +25,12 @@ type InstrumentConfig struct {
 }

 // Description describes the instrument in human-readable terms.
-func (cfg InstrumentConfig) Description() string {
+func (cfg *InstrumentConfig) Description() string {
 	return cfg.description
 }

 // Unit describes the measurement unit for a instrument.
-func (cfg InstrumentConfig) Unit() unit.Unit {
+func (cfg *InstrumentConfig) Unit() unit.Unit {
 	return cfg.unit
 }

@ -38,7 +38,7 @@ func (cfg InstrumentConfig) Unit() unit.Unit {
 type InstrumentOption interface {
 	// ApplyMeter is used to set a InstrumentOption value of a
 	// InstrumentConfig.
-	applyInstrument(*InstrumentConfig)
+	applyInstrument(InstrumentConfig) InstrumentConfig
 }

 // NewInstrumentConfig creates a new InstrumentConfig
@ -46,28 +46,30 @@ type InstrumentOption interface {
 func NewInstrumentConfig(opts ...InstrumentOption) InstrumentConfig {
 	var config InstrumentConfig
 	for _, o := range opts {
-		o.applyInstrument(&config)
+		config = o.applyInstrument(config)
 	}
 	return config
 }

-type instrumentOptionFunc func(*InstrumentConfig)
+type instrumentOptionFunc func(InstrumentConfig) InstrumentConfig

-func (fn instrumentOptionFunc) applyInstrument(cfg *InstrumentConfig) {
-	fn(cfg)
+func (fn instrumentOptionFunc) applyInstrument(cfg InstrumentConfig) InstrumentConfig {
+	return fn(cfg)
 }

 // WithDescription applies provided description.
 func WithDescription(desc string) InstrumentOption {
-	return instrumentOptionFunc(func(cfg *InstrumentConfig) {
+	return instrumentOptionFunc(func(cfg InstrumentConfig) InstrumentConfig {
 		cfg.description = desc
+		return cfg
 	})
 }

 // WithUnit applies provided unit.
 func WithUnit(unit unit.Unit) InstrumentOption {
-	return instrumentOptionFunc(func(cfg *InstrumentConfig) {
+	return instrumentOptionFunc(func(cfg InstrumentConfig) InstrumentConfig {
 		cfg.unit = unit
+		return cfg
 	})
 }

@ -78,19 +80,19 @@ type MeterConfig struct {
 }

 // InstrumentationVersion is the version of the library providing instrumentation.
-func (cfg MeterConfig) InstrumentationVersion() string {
+func (cfg *MeterConfig) InstrumentationVersion() string {
 	return cfg.instrumentationVersion
 }

 // SchemaURL is the schema_url of the library providing instrumentation.
-func (cfg MeterConfig) SchemaURL() string {
+func (cfg *MeterConfig) SchemaURL() string {
 	return cfg.schemaURL
 }

 // MeterOption is an interface for applying Meter options.
 type MeterOption interface {
 	// ApplyMeter is used to set a MeterOption value of a MeterConfig.
-	applyMeter(*MeterConfig)
+	applyMeter(MeterConfig) MeterConfig
 }

 // NewMeterConfig creates a new MeterConfig and applies
@ -98,27 +100,29 @@ type MeterOption interface {
 func NewMeterConfig(opts ...MeterOption) MeterConfig {
 	var config MeterConfig
 	for _, o := range opts {
-		o.applyMeter(&config)
+		config = o.applyMeter(config)
 	}
 	return config
 }

-type meterOptionFunc func(*MeterConfig)
+type meterOptionFunc func(MeterConfig) MeterConfig

-func (fn meterOptionFunc) applyMeter(cfg *MeterConfig) {
-	fn(cfg)
+func (fn meterOptionFunc) applyMeter(cfg MeterConfig) MeterConfig {
+	return fn(cfg)
 }

 // WithInstrumentationVersion sets the instrumentation version.
 func WithInstrumentationVersion(version string) MeterOption {
-	return meterOptionFunc(func(config *MeterConfig) {
+	return meterOptionFunc(func(config MeterConfig) MeterConfig {
 		config.instrumentationVersion = version
+		return config
 	})
 }

 // WithSchemaURL sets the schema URL.
 func WithSchemaURL(schemaURL string) MeterOption {
-	return meterOptionFunc(func(config *MeterConfig) {
+	return meterOptionFunc(func(config MeterConfig) MeterConfig {
 		config.schemaURL = schemaURL
+		return config
 	})
 }
--- a/vendor/go.opentelemetry.io/otel/metric/sdkapi/noop.go
+++ b/vendor/go.opentelemetry.io/otel/metric/sdkapi/noop.go
@ -21,7 +21,9 @@ import (
 	"go.opentelemetry.io/otel/metric/number"
 )

-type noopInstrument struct{}
+type noopInstrument struct {
+	descriptor Descriptor
+}
 type noopSyncInstrument struct{ noopInstrument }
 type noopAsyncInstrument struct{ noopInstrument }

@ -31,21 +33,33 @@ var _ AsyncImpl = noopAsyncInstrument{}
 // NewNoopSyncInstrument returns a No-op implementation of the
 // synchronous instrument interface.
 func NewNoopSyncInstrument() SyncImpl {
-	return noopSyncInstrument{}
+	return noopSyncInstrument{
+		noopInstrument{
+			descriptor: Descriptor{
+				instrumentKind: CounterInstrumentKind,
+			},
+		},
+	}
 }

 // NewNoopAsyncInstrument returns a No-op implementation of the
 // asynchronous instrument interface.
 func NewNoopAsyncInstrument() AsyncImpl {
-	return noopAsyncInstrument{}
+	return noopAsyncInstrument{
+		noopInstrument{
+			descriptor: Descriptor{
+				instrumentKind: CounterObserverInstrumentKind,
+			},
+		},
+	}
 }

 func (noopInstrument) Implementation() interface{} {
 	return nil
 }

-func (noopInstrument) Descriptor() Descriptor {
-	return Descriptor{}
+func (n noopInstrument) Descriptor() Descriptor {
+	return n.descriptor
 }

 func (noopSyncInstrument) RecordOne(context.Context, number.Number, []attribute.KeyValue) {
--- a/vendor/go.opentelemetry.io/otel/metric/sdkapi/sdkapi.go
+++ b/vendor/go.opentelemetry.io/otel/metric/sdkapi/sdkapi.go
@ -72,7 +72,7 @@ type AsyncImpl interface {
 // AsyncBatchRunner.  SDKs will encounter an error if the AsyncRunner
 // does not satisfy one of these interfaces.
 type AsyncRunner interface {
-	// AnyRunner() is a non-exported method with no functional use
+	// AnyRunner is a non-exported method with no functional use
 	// other than to make this a non-empty interface.
 	AnyRunner()
 }
--- a/vendor/go.opentelemetry.io/otel/pre_release.sh
+++ b/vendor/go.opentelemetry.io/otel/pre_release.sh
@ -1,95 +0,0 @@
-#!/bin/bash
-
-# 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.
-
-set -e
-
-help()
-{
-   printf "\n"
-   printf "Usage: $0 -t tag\n"
-   printf "\t-t Unreleased tag. Update all go.mod with this tag.\n"
-   exit 1 # Exit script after printing help
-}
-
-while getopts "t:" opt
-do
-   case "$opt" in
-      t ) TAG="$OPTARG" ;;
-      ? ) help ;; # Print help
-   esac
-done
-
-# Print help in case parameters are empty
-if [ -z "$TAG" ]
-then
-   printf "Tag is missing\n";
-   help
-fi
-
-# Validate semver
-SEMVER_REGEX="^v(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(\\-[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?$"
-if [[ "${TAG}" =~ ${SEMVER_REGEX} ]]; then
-	printf "${TAG} is valid semver tag.\n"
-else
-	printf "${TAG} is not a valid semver tag.\n"
-	exit -1
-fi
-
-TAG_FOUND=`git tag --list ${TAG}`
-if [[ ${TAG_FOUND} = ${TAG} ]] ; then
-        printf "Tag ${TAG} already exists\n"
-        exit -1
-fi
-
-# Get version for version.go
-OTEL_VERSION=$(echo "${TAG}" | grep -o '^v[0-9]\+\.[0-9]\+\.[0-9]\+')
-# Strip leading v
-OTEL_VERSION="${OTEL_VERSION#v}"
-
-cd $(dirname $0)
-
-if ! git diff --quiet; then \
-	printf "Working tree is not clean, can't proceed with the release process\n"
-	git status
-	git diff
-	exit 1
-fi
-
-# Update version.go
-cp ./version.go ./version.go.bak
-sed "s/\(return \"\)[0-9]*\.[0-9]*\.[0-9]*\"/\1${OTEL_VERSION}\"/" ./version.go.bak >./version.go
-rm -f ./version.go.bak
-
-# Update go.mod
-git checkout -b pre_release_${TAG} main
-PACKAGE_DIRS=$(find . -mindepth 2 -type f -name 'go.mod' -exec dirname {} \; | egrep -v 'tools' | sed 's/^\.\///' | sort)
-
-for dir in $PACKAGE_DIRS; do
-	cp "${dir}/go.mod" "${dir}/go.mod.bak"
-	sed "s/opentelemetry.io\/otel\([^ ]*\) v[0-9]*\.[0-9]*\.[0-9]/opentelemetry.io\/otel\1 ${TAG}/" "${dir}/go.mod.bak" >"${dir}/go.mod"
-	rm -f "${dir}/go.mod.bak"
-done
-
-# Run lint to update go.sum
-make lint
-
-# Add changes and commit.
-git add .
-make ci
-git commit -m "Prepare for releasing $TAG"
-
-printf "Now run following to verify the changes.\ngit diff main\n"
-printf "\nThen push the changes to upstream\n"
--- a/vendor/go.opentelemetry.io/otel/sdk/internal/env/env.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/internal/env/env.go
@ -0,0 +1,88 @@
+// 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 env // import "go.opentelemetry.io/otel/sdk/internal/env"
+
+import (
+	"os"
+	"strconv"
+
+	"go.opentelemetry.io/otel/internal/global"
+)
+
+// Environment variable names
+const (
+	// BatchSpanProcessorScheduleDelayKey
+	// Delay interval between two consecutive exports.
+	// i.e. 5000
+	BatchSpanProcessorScheduleDelayKey = "OTEL_BSP_SCHEDULE_DELAY"
+	// BatchSpanProcessorExportTimeoutKey
+	// Maximum allowed time to export data.
+	// i.e. 3000
+	BatchSpanProcessorExportTimeoutKey = "OTEL_BSP_EXPORT_TIMEOUT"
+	// BatchSpanProcessorMaxQueueSizeKey
+	// Maximum queue size
+	// i.e. 2048
+	BatchSpanProcessorMaxQueueSizeKey = "OTEL_BSP_MAX_QUEUE_SIZE"
+	// BatchSpanProcessorMaxExportBatchSizeKey
+	// Maximum batch size
+	// Note: Must be less than or equal to EnvBatchSpanProcessorMaxQueueSize
+	// i.e. 512
+	BatchSpanProcessorMaxExportBatchSizeKey = "OTEL_BSP_MAX_EXPORT_BATCH_SIZE"
+)
+
+// IntEnvOr returns the int value of the environment variable with name key if
+// it exists and the value is an int. Otherwise, defaultValue is returned.
+func IntEnvOr(key string, defaultValue int) int {
+	value, ok := os.LookupEnv(key)
+	if !ok {
+		return defaultValue
+	}
+
+	intValue, err := strconv.Atoi(value)
+	if err != nil {
+		global.Info("Got invalid value, number value expected.", key, value)
+		return defaultValue
+	}
+
+	return intValue
+}
+
+// BatchSpanProcessorScheduleDelay returns the environment variable value for
+// the OTEL_BSP_SCHEDULE_DELAY key if it exists, otherwise defaultValue is
+// returned.
+func BatchSpanProcessorScheduleDelay(defaultValue int) int {
+	return IntEnvOr(BatchSpanProcessorScheduleDelayKey, defaultValue)
+}
+
+// BatchSpanProcessorExportTimeout returns the environment variable value for
+// the OTEL_BSP_EXPORT_TIMEOUT key if it exists, otherwise defaultValue is
+// returned.
+func BatchSpanProcessorExportTimeout(defaultValue int) int {
+	return IntEnvOr(BatchSpanProcessorExportTimeoutKey, defaultValue)
+}
+
+// BatchSpanProcessorMaxQueueSize returns the environment variable value for
+// the OTEL_BSP_MAX_QUEUE_SIZE key if it exists, otherwise defaultValue is
+// returned.
+func BatchSpanProcessorMaxQueueSize(defaultValue int) int {
+	return IntEnvOr(BatchSpanProcessorMaxQueueSizeKey, defaultValue)
+}
+
+// BatchSpanProcessorMaxExportBatchSize returns the environment variable value for
+// the OTEL_BSP_MAX_EXPORT_BATCH_SIZE key if it exists, otherwise defaultValue
+// is returned.
+func BatchSpanProcessorMaxExportBatchSize(defaultValue int) int {
+	return IntEnvOr(BatchSpanProcessorMaxExportBatchSizeKey, defaultValue)
+}
--- a/vendor/go.opentelemetry.io/otel/sdk/internal/sanitize.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/internal/sanitize.go
@ -1,50 +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 internal // import "go.opentelemetry.io/otel/sdk/internal"
-
-import (
-	"strings"
-	"unicode"
-)
-
-const labelKeySizeLimit = 100
-
-// Sanitize returns a string that is trunacated to 100 characters if it's too
-// long, and replaces non-alphanumeric characters to underscores.
-func Sanitize(s string) string {
-	if len(s) == 0 {
-		return s
-	}
-	if len(s) > labelKeySizeLimit {
-		s = s[:labelKeySizeLimit]
-	}
-	s = strings.Map(sanitizeRune, s)
-	if unicode.IsDigit(rune(s[0])) {
-		s = "key_" + s
-	}
-	if s[0] == '_' {
-		s = "key" + s
-	}
-	return s
-}
-
-// converts anything that is not a letter or digit to an underscore
-func sanitizeRune(r rune) rune {
-	if unicode.IsLetter(r) || unicode.IsDigit(r) {
-		return r
-	}
-	// Everything else turns into an underscore
-	return '_'
-}
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/config.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/config.go
@ -31,7 +31,7 @@ type config struct {
 // Option is the interface that applies a configuration option.
 type Option interface {
 	// apply sets the Option value of a config.
-	apply(*config)
+	apply(config) config
 }

 // WithAttributes adds attributes to the configured Resource.
@ -56,8 +56,9 @@ type detectorsOption struct {
 	detectors []Detector
 }

-func (o detectorsOption) apply(cfg *config) {
+func (o detectorsOption) apply(cfg config) config {
 	cfg.detectors = append(cfg.detectors, o.detectors...)
+	return cfg
 }

 // WithFromEnv adds attributes from environment variables to the configured resource.
@ -82,8 +83,9 @@ func WithSchemaURL(schemaURL string) Option {

 type schemaURLOption string

-func (o schemaURLOption) apply(cfg *config) {
+func (o schemaURLOption) apply(cfg config) config {
 	cfg.schemaURL = string(o)
+	return cfg
 }

 // WithOS adds all the OS attributes to the configured Resource.
--- a/vendor/go.opentelemetry.io/otel/sdk/resource/resource.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/resource/resource.go
@ -48,7 +48,7 @@ var errMergeConflictSchemaURL = errors.New("cannot merge resource due to conflic
 func New(ctx context.Context, opts ...Option) (*Resource, error) {
 	cfg := config{}
 	for _, opt := range opts {
-		opt.apply(&cfg)
+		cfg = opt.apply(cfg)
 	}

 	resource, err := Detect(ctx, cfg.detectors...)
@ -109,6 +109,17 @@ func (r *Resource) String() string {
 	return r.attrs.Encoded(attribute.DefaultEncoder())
 }

+// MarshalLog is the marshaling function used by the logging system to represent this exporter.
+func (r *Resource) MarshalLog() interface{} {
+	return struct {
+		Attributes attribute.Set
+		SchemaURL  string
+	}{
+		Attributes: r.attrs,
+		SchemaURL:  r.schemaURL,
+	}
+}
+
 // Attributes returns a copy of attributes from the resource in a sorted order.
 // To avoid allocating a new slice, use an iterator.
 func (r *Resource) Attributes() []attribute.KeyValue {
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/attributesmap.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/attributesmap.go
@ -1,91 +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 trace // import "go.opentelemetry.io/otel/sdk/trace"
-
-import (
-	"container/list"
-
-	"go.opentelemetry.io/otel/attribute"
-)
-
-// attributesMap is a capped map of attributes, holding the most recent attributes.
-// Eviction is done via a LRU method, the oldest entry is removed to create room for a new entry.
-// Updates are allowed and they refresh the usage of the key.
-//
-// This is based from https://github.com/hashicorp/golang-lru/blob/master/simplelru/lru.go
-// With a subset of the its operations and specific for holding attribute.KeyValue
-type attributesMap struct {
-	attributes   map[attribute.Key]*list.Element
-	evictList    *list.List
-	droppedCount int
-	capacity     int
-}
-
-func newAttributesMap(capacity int) *attributesMap {
-	lm := &attributesMap{
-		attributes: make(map[attribute.Key]*list.Element),
-		evictList:  list.New(),
-		capacity:   capacity,
-	}
-	return lm
-}
-
-func (am *attributesMap) add(kv attribute.KeyValue) {
-	// Check for existing item
-	if ent, ok := am.attributes[kv.Key]; ok {
-		am.evictList.MoveToFront(ent)
-		ent.Value = &kv
-		return
-	}
-
-	// Add new item
-	entry := am.evictList.PushFront(&kv)
-	am.attributes[kv.Key] = entry
-
-	// Verify size not exceeded
-	if am.evictList.Len() > am.capacity {
-		am.removeOldest()
-		am.droppedCount++
-	}
-}
-
-// toKeyValue copies the attributesMap into a slice of attribute.KeyValue and
-// returns it. If the map is empty, a nil is returned.
-// TODO: Is it more efficient to return a pointer to the slice?
-func (am *attributesMap) toKeyValue() []attribute.KeyValue {
-	len := am.evictList.Len()
-	if len == 0 {
-		return nil
-	}
-
-	attributes := make([]attribute.KeyValue, 0, len)
-	for ent := am.evictList.Back(); ent != nil; ent = ent.Prev() {
-		if value, ok := ent.Value.(*attribute.KeyValue); ok {
-			attributes = append(attributes, *value)
-		}
-	}
-
-	return attributes
-}
-
-// removeOldest removes the oldest item from the cache.
-func (am *attributesMap) removeOldest() {
-	ent := am.evictList.Back()
-	if ent != nil {
-		am.evictList.Remove(ent)
-		kv := ent.Value.(*attribute.KeyValue)
-		delete(am.attributes, kv.Key)
-	}
-}
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/batch_span_processor.go
@ -23,14 +23,15 @@ import (

 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/internal/global"
+	"go.opentelemetry.io/otel/sdk/internal/env"
 	"go.opentelemetry.io/otel/trace"
 )

 // Defaults for BatchSpanProcessorOptions.
 const (
 	DefaultMaxQueueSize       = 2048
-	DefaultBatchTimeout       = 5000 * time.Millisecond
-	DefaultExportTimeout      = 30000 * time.Millisecond
+	DefaultScheduleDelay      = 5000
+	DefaultExportTimeout      = 30000
 	DefaultMaxExportBatchSize = 512
 )

@ -89,11 +90,22 @@ var _ SpanProcessor = (*batchSpanProcessor)(nil)
 //
 // If the exporter is nil, the span processor will preform no action.
 func NewBatchSpanProcessor(exporter SpanExporter, options ...BatchSpanProcessorOption) SpanProcessor {
+	maxQueueSize := env.BatchSpanProcessorMaxQueueSize(DefaultMaxQueueSize)
+	maxExportBatchSize := env.BatchSpanProcessorMaxExportBatchSize(DefaultMaxExportBatchSize)
+
+	if maxExportBatchSize > maxQueueSize {
+		if DefaultMaxExportBatchSize > maxQueueSize {
+			maxExportBatchSize = maxQueueSize
+		} else {
+			maxExportBatchSize = DefaultMaxExportBatchSize
+		}
+	}
+
 	o := BatchSpanProcessorOptions{
-		BatchTimeout:       DefaultBatchTimeout,
-		ExportTimeout:      DefaultExportTimeout,
-		MaxQueueSize:       DefaultMaxQueueSize,
-		MaxExportBatchSize: DefaultMaxExportBatchSize,
+		BatchTimeout:       time.Duration(env.BatchSpanProcessorScheduleDelay(DefaultScheduleDelay)) * time.Millisecond,
+		ExportTimeout:      time.Duration(env.BatchSpanProcessorExportTimeout(DefaultExportTimeout)) * time.Millisecond,
+		MaxQueueSize:       maxQueueSize,
+		MaxExportBatchSize: maxExportBatchSize,
 	}
 	for _, opt := range options {
 		opt(&o)
@ -238,7 +250,7 @@ func (bsp *batchSpanProcessor) exportSpans(ctx context.Context) error {
 	}

 	if l := len(bsp.batch); l > 0 {
-		global.Debug("exporting spans", "count", len(bsp.batch))
+		global.Debug("exporting spans", "count", len(bsp.batch), "dropped", bsp.dropped)
 		err := bsp.e.ExportSpans(ctx, bsp.batch)

 		// A new batch is always created after exporting, even if the batch failed to be exported.
@ -369,3 +381,16 @@ func (bsp *batchSpanProcessor) enqueueBlockOnQueueFull(ctx context.Context, sd R
 	}
 	return false
 }
+
+// MarshalLog is the marshaling function used by the logging system to represent this exporter.
+func (bsp *batchSpanProcessor) MarshalLog() interface{} {
+	return struct {
+		Type         string
+		SpanExporter SpanExporter
+		Config       BatchSpanProcessorOptions
+	}{
+		Type:         "BatchSpanProcessor",
+		SpanExporter: bsp.e,
+		Config:       bsp.o,
+	}
+}
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/evictedqueue.go
@ -14,24 +14,25 @@

 package trace // import "go.opentelemetry.io/otel/sdk/trace"

+// evictedQueue is a FIFO queue with a configurable capacity.
 type evictedQueue struct {
 	queue        []interface{}
 	capacity     int
 	droppedCount int
 }

-func newEvictedQueue(capacity int) *evictedQueue {
-	eq := &evictedQueue{
-		capacity: capacity,
-		queue:    make([]interface{}, 0),
-	}
-
-	return eq
+func newEvictedQueue(capacity int) evictedQueue {
+	// Do not pre-allocate queue, do this lazily.
+	return evictedQueue{capacity: capacity}
 }

+// add adds value to the evictedQueue eq. If eq is at capacity, the oldest
+// queued value will be discarded and the drop count incremented.
 func (eq *evictedQueue) add(value interface{}) {
 	if len(eq.queue) == eq.capacity {
-		eq.queue = eq.queue[1:]
+		// Drop first-in while avoiding allocating more capacity to eq.queue.
+		copy(eq.queue[:eq.capacity-1], eq.queue[1:])
+		eq.queue = eq.queue[:eq.capacity-1]
 		eq.droppedCount++
 	}
 	eq.queue = append(eq.queue, value)
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/provider.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/provider.go
@ -21,6 +21,7 @@ import (
 	"sync/atomic"

 	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/internal/global"
 	"go.opentelemetry.io/otel/sdk/instrumentation"
 	"go.opentelemetry.io/otel/sdk/resource"
 	"go.opentelemetry.io/otel/trace"
@ -52,14 +53,34 @@ type tracerProviderConfig struct {
 	resource *resource.Resource
 }

+// MarshalLog is the marshaling function used by the logging system to represent this exporter.
+func (cfg tracerProviderConfig) MarshalLog() interface{} {
+	return struct {
+		SpanProcessors  []SpanProcessor
+		SamplerType     string
+		IDGeneratorType string
+		SpanLimits      SpanLimits
+		Resource        *resource.Resource
+	}{
+		SpanProcessors:  cfg.processors,
+		SamplerType:     fmt.Sprintf("%T", cfg.sampler),
+		IDGeneratorType: fmt.Sprintf("%T", cfg.idGenerator),
+		SpanLimits:      cfg.spanLimits,
+		Resource:        cfg.resource,
+	}
+}
+
 type TracerProvider struct {
 	mu             sync.Mutex
 	namedTracer    map[instrumentation.Library]*tracer
 	spanProcessors atomic.Value
-	sampler        Sampler
-	idGenerator    IDGenerator
-	spanLimits     SpanLimits
-	resource       *resource.Resource
+
+	// These fields are not protected by the lock mu. They are assumed to be
+	// immutable after creation of the TracerProvider.
+	sampler     Sampler
+	idGenerator IDGenerator
+	spanLimits  SpanLimits
+	resource    *resource.Resource
 }

 var _ trace.TracerProvider = &TracerProvider{}
@ -75,13 +96,13 @@ var _ trace.TracerProvider = &TracerProvider{}
 // The passed opts are used to override these default values and configure the
 // returned TracerProvider appropriately.
 func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider {
-	o := &tracerProviderConfig{}
+	o := tracerProviderConfig{}

 	for _, opt := range opts {
-		opt.apply(o)
+		o = opt.apply(o)
 	}

-	ensureValidTracerProviderConfig(o)
+	o = ensureValidTracerProviderConfig(o)

 	tp := &TracerProvider{
 		namedTracer: make(map[instrumentation.Library]*tracer),
@ -91,6 +112,8 @@ func NewTracerProvider(opts ...TracerProviderOption) *TracerProvider {
 		resource:    o.resource,
 	}

+	global.Info("TracerProvider created", "config", o)
+
 	for _, sp := range o.processors {
 		tp.RegisterSpanProcessor(sp)
 	}
@ -125,6 +148,7 @@ func (p *TracerProvider) Tracer(name string, opts ...trace.TracerOption) trace.T
 			instrumentationLibrary: il,
 		}
 		p.namedTracer[il] = t
+		global.Info("Tracer created", "name", name, "version", c.InstrumentationVersion(), "schemaURL", c.SchemaURL())
 	}
 	return t
 }
@ -235,13 +259,13 @@ func (p *TracerProvider) Shutdown(ctx context.Context) error {
 }

 type TracerProviderOption interface {
-	apply(*tracerProviderConfig)
+	apply(tracerProviderConfig) tracerProviderConfig
 }

-type traceProviderOptionFunc func(*tracerProviderConfig)
+type traceProviderOptionFunc func(tracerProviderConfig) tracerProviderConfig

-func (fn traceProviderOptionFunc) apply(cfg *tracerProviderConfig) {
-	fn(cfg)
+func (fn traceProviderOptionFunc) apply(cfg tracerProviderConfig) tracerProviderConfig {
+	return fn(cfg)
 }

 // WithSyncer registers the exporter with the TracerProvider using a
@ -264,8 +288,9 @@ func WithBatcher(e SpanExporter, opts ...BatchSpanProcessorOption) TracerProvide

 // WithSpanProcessor registers the SpanProcessor with a TracerProvider.
 func WithSpanProcessor(sp SpanProcessor) TracerProviderOption {
-	return traceProviderOptionFunc(func(cfg *tracerProviderConfig) {
+	return traceProviderOptionFunc(func(cfg tracerProviderConfig) tracerProviderConfig {
 		cfg.processors = append(cfg.processors, sp)
+		return cfg
 	})
 }

@ -277,12 +302,13 @@ func WithSpanProcessor(sp SpanProcessor) TracerProviderOption {
 // If this option is not used, the TracerProvider will use the
 // resource.Default() Resource by default.
 func WithResource(r *resource.Resource) TracerProviderOption {
-	return traceProviderOptionFunc(func(cfg *tracerProviderConfig) {
+	return traceProviderOptionFunc(func(cfg tracerProviderConfig) tracerProviderConfig {
 		var err error
 		cfg.resource, err = resource.Merge(resource.Environment(), r)
 		if err != nil {
 			otel.Handle(err)
 		}
+		return cfg
 	})
 }

@ -294,10 +320,11 @@ func WithResource(r *resource.Resource) TracerProviderOption {
 // If this option is not used, the TracerProvider will use a random number
 // IDGenerator by default.
 func WithIDGenerator(g IDGenerator) TracerProviderOption {
-	return traceProviderOptionFunc(func(cfg *tracerProviderConfig) {
+	return traceProviderOptionFunc(func(cfg tracerProviderConfig) tracerProviderConfig {
 		if g != nil {
 			cfg.idGenerator = g
 		}
+		return cfg
 	})
 }

@ -309,10 +336,11 @@ func WithIDGenerator(g IDGenerator) TracerProviderOption {
 // If this option is not used, the TracerProvider will use a
 // ParentBased(AlwaysSample) Sampler by default.
 func WithSampler(s Sampler) TracerProviderOption {
-	return traceProviderOptionFunc(func(cfg *tracerProviderConfig) {
+	return traceProviderOptionFunc(func(cfg tracerProviderConfig) tracerProviderConfig {
 		if s != nil {
 			cfg.sampler = s
 		}
+		return cfg
 	})
 }

@ -324,13 +352,14 @@ func WithSampler(s Sampler) TracerProviderOption {
 // If this option is not used, the TracerProvider will use the default
 // SpanLimits.
 func WithSpanLimits(sl SpanLimits) TracerProviderOption {
-	return traceProviderOptionFunc(func(cfg *tracerProviderConfig) {
+	return traceProviderOptionFunc(func(cfg tracerProviderConfig) tracerProviderConfig {
 		cfg.spanLimits = sl
+		return cfg
 	})
 }

 // ensureValidTracerProviderConfig ensures that given TracerProviderConfig is valid.
-func ensureValidTracerProviderConfig(cfg *tracerProviderConfig) {
+func ensureValidTracerProviderConfig(cfg tracerProviderConfig) tracerProviderConfig {
 	if cfg.sampler == nil {
 		cfg.sampler = ParentBased(AlwaysSample())
 	}
@ -341,4 +370,5 @@ func ensureValidTracerProviderConfig(cfg *tracerProviderConfig) {
 	if cfg.resource == nil {
 		cfg.resource = resource.Default()
 	}
+	return cfg
 }
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/sampling.go
@ -187,7 +187,7 @@ func configureSamplersForParentBased(samplers []ParentBasedSamplerOption) sample
 	}

 	for _, so := range samplers {
-		so.apply(&c)
+		c = so.apply(c)
 	}

 	return c
@ -201,7 +201,7 @@ type samplerConfig struct {

 // ParentBasedSamplerOption configures the sampler for a particular sampling case.
 type ParentBasedSamplerOption interface {
-	apply(*samplerConfig)
+	apply(samplerConfig) samplerConfig
 }

 // WithRemoteParentSampled sets the sampler for the case of sampled remote parent.
@ -213,8 +213,9 @@ type remoteParentSampledOption struct {
 	s Sampler
 }

-func (o remoteParentSampledOption) apply(config *samplerConfig) {
+func (o remoteParentSampledOption) apply(config samplerConfig) samplerConfig {
 	config.remoteParentSampled = o.s
+	return config
 }

 // WithRemoteParentNotSampled sets the sampler for the case of remote parent
@ -227,8 +228,9 @@ type remoteParentNotSampledOption struct {
 	s Sampler
 }

-func (o remoteParentNotSampledOption) apply(config *samplerConfig) {
+func (o remoteParentNotSampledOption) apply(config samplerConfig) samplerConfig {
 	config.remoteParentNotSampled = o.s
+	return config
 }

 // WithLocalParentSampled sets the sampler for the case of sampled local parent.
@ -240,8 +242,9 @@ type localParentSampledOption struct {
 	s Sampler
 }

-func (o localParentSampledOption) apply(config *samplerConfig) {
+func (o localParentSampledOption) apply(config samplerConfig) samplerConfig {
 	config.localParentSampled = o.s
+	return config
 }

 // WithLocalParentNotSampled sets the sampler for the case of local parent
@ -254,8 +257,9 @@ type localParentNotSampledOption struct {
 	s Sampler
 }

-func (o localParentNotSampledOption) apply(config *samplerConfig) {
+func (o localParentNotSampledOption) apply(config samplerConfig) samplerConfig {
 	config.localParentNotSampled = o.s
+	return config
 }

 func (pb parentBased) ShouldSample(p SamplingParameters) SamplingResult {
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/simple_span_processor.go
@ -115,3 +115,14 @@ func (ssp *simpleSpanProcessor) Shutdown(ctx context.Context) error {
 func (ssp *simpleSpanProcessor) ForceFlush(context.Context) error {
 	return nil
 }
+
+// MarshalLog is the marshaling function used by the logging system to represent this exporter.
+func (ssp *simpleSpanProcessor) MarshalLog() interface{} {
+	return struct {
+		Type     string
+		Exporter SpanExporter
+	}{
+		Type:     "SimpleSpanProcessor",
+		Exporter: ssp.exporter,
+	}
+}
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/span.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/span.go
@ -54,6 +54,7 @@ type ReadOnlySpan interface {
 	// the span has not ended.
 	EndTime() time.Time
 	// Attributes returns the defining attributes of the span.
+	// The order of the returned attributes is not guaranteed to be stable across invocations.
 	Attributes() []attribute.KeyValue
 	// Links returns all the links the span has to other spans.
 	Links() []Link
@ -126,35 +127,29 @@ type recordingSpan struct {
 	// childSpanCount holds the number of child spans created for this span.
 	childSpanCount int

-	// resource contains attributes representing an entity that produced this
-	// span.
-	resource *resource.Resource
-
-	// instrumentationLibrary defines the instrumentation library used to
-	// provide instrumentation.
-	instrumentationLibrary instrumentation.Library
-
 	// spanContext holds the SpanContext of this span.
 	spanContext trace.SpanContext

-	// attributes are capped at configured limit. When the capacity is reached
-	// an oldest entry is removed to create room for a new entry.
-	attributes *attributesMap
+	// attributes is a collection of user provided key/values. The collection
+	// is constrained by a configurable maximum held by the parent
+	// TracerProvider. When additional attributes are added after this maximum
+	// is reached these attributes the user is attempting to add are dropped.
+	// This dropped number of attributes is tracked and reported in the
+	// ReadOnlySpan exported when the span ends.
+	attributes        []attribute.KeyValue
+	droppedAttributes int

 	// events are stored in FIFO queue capped by configured limit.
-	events *evictedQueue
+	events evictedQueue

 	// links are stored in FIFO queue capped by configured limit.
-	links *evictedQueue
+	links evictedQueue

 	// executionTracerTaskEnd ends the execution tracer span.
 	executionTracerTaskEnd func()

 	// tracer is the SDK tracer that created this span.
 	tracer *tracer
-
-	// spanLimits holds the limits to this span.
-	spanLimits SpanLimits
 }

 var _ ReadWriteSpan = (*recordingSpan)(nil)
@ -205,11 +200,80 @@ func (s *recordingSpan) SetStatus(code codes.Code, description string) {
 // will be overwritten with the value contained in attributes.
 //
 // If this span is not being recorded than this method does nothing.
+//
+// If adding attributes to the span would exceed the maximum amount of
+// attributes the span is configured to have, the last added attributes will
+// be dropped.
 func (s *recordingSpan) SetAttributes(attributes ...attribute.KeyValue) {
 	if !s.IsRecording() {
 		return
 	}
-	s.copyToCappedAttributes(attributes...)
+
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// If adding these attributes could exceed the capacity of s perform a
+	// de-duplication and truncation while adding to avoid over allocation.
+	if len(s.attributes)+len(attributes) > s.tracer.provider.spanLimits.AttributeCountLimit {
+		s.addOverCapAttrs(attributes)
+		return
+	}
+
+	// Otherwise, add without deduplication. When attributes are read they
+	// will be deduplicated, optimizing the operation.
+	for _, a := range attributes {
+		if !a.Valid() {
+			// Drop all invalid attributes.
+			s.droppedAttributes++
+			continue
+		}
+		s.attributes = append(s.attributes, a)
+	}
+}
+
+// addOverCapAttrs adds the attributes attrs to the span s while
+// de-duplicating the attributes of s and attrs and dropping attributes that
+// exceed the capacity of s.
+//
+// This method assumes s.mu.Lock is held by the caller.
+//
+// This method should only be called when there is a possibility that adding
+// attrs to s will exceed the capacity of s. Otherwise, attrs should be added
+// to s without checking for duplicates and all retrieval methods of the
+// attributes for s will de-duplicate as needed.
+func (s *recordingSpan) addOverCapAttrs(attrs []attribute.KeyValue) {
+	// In order to not allocate more capacity to s.attributes than needed,
+	// prune and truncate this addition of attributes while adding.
+
+	// Do not set a capacity when creating this map. Benchmark testing has
+	// showed this to only add unused memory allocations in general use.
+	exists := make(map[attribute.Key]int)
+	s.dedupeAttrsFromRecord(&exists)
+
+	// Now that s.attributes is deduplicated, adding unique attributes up to
+	// the capacity of s will not over allocate s.attributes.
+	for _, a := range attrs {
+		if !a.Valid() {
+			// Drop all invalid attributes.
+			s.droppedAttributes++
+			continue
+		}
+
+		if idx, ok := exists[a.Key]; ok {
+			// Perform all updates before dropping, even when at capacity.
+			s.attributes[idx] = a
+			continue
+		}
+
+		if len(s.attributes) >= s.tracer.provider.spanLimits.AttributeCountLimit {
+			// Do not just drop all of the remaining attributes, make sure
+			// updates are checked and performed.
+			s.droppedAttributes++
+		} else {
+			s.attributes = append(s.attributes, a)
+			exists[a.Key] = len(s.attributes) - 1
+		}
+	}
 }

 // End ends the span. This method does nothing if the span is already ended or
@ -336,9 +400,9 @@ func (s *recordingSpan) addEvent(name string, o ...trace.EventOption) {
 	// Discard over limited attributes
 	attributes := c.Attributes()
 	var discarded int
-	if len(attributes) > s.spanLimits.AttributePerEventCountLimit {
-		discarded = len(attributes) - s.spanLimits.AttributePerEventCountLimit
-		attributes = attributes[:s.spanLimits.AttributePerEventCountLimit]
+	if len(attributes) > s.tracer.provider.spanLimits.AttributePerEventCountLimit {
+		discarded = len(attributes) - s.tracer.provider.spanLimits.AttributePerEventCountLimit
+		attributes = attributes[:s.tracer.provider.spanLimits.AttributePerEventCountLimit]
 	}
 	s.mu.Lock()
 	defer s.mu.Unlock()
@ -399,13 +463,45 @@ func (s *recordingSpan) EndTime() time.Time {
 }

 // Attributes returns the attributes of this span.
+//
+// The order of the returned attributes is not guaranteed to be stable.
 func (s *recordingSpan) Attributes() []attribute.KeyValue {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	if s.attributes.evictList.Len() == 0 {
-		return []attribute.KeyValue{}
+	s.dedupeAttrs()
+	return s.attributes
+}
+
+// dedupeAttrs deduplicates the attributes of s to fit capacity.
+//
+// This method assumes s.mu.Lock is held by the caller.
+func (s *recordingSpan) dedupeAttrs() {
+	// Do not set a capacity when creating this map. Benchmark testing has
+	// showed this to only add unused memory allocations in general use.
+	exists := make(map[attribute.Key]int)
+	s.dedupeAttrsFromRecord(&exists)
+}
+
+// dedupeAttrsFromRecord deduplicates the attributes of s to fit capacity
+// using record as the record of unique attribute keys to their index.
+//
+// This method assumes s.mu.Lock is held by the caller.
+func (s *recordingSpan) dedupeAttrsFromRecord(record *map[attribute.Key]int) {
+	// Use the fact that slices share the same backing array.
+	unique := s.attributes[:0]
+	for _, a := range s.attributes {
+		if idx, ok := (*record)[a.Key]; ok {
+			unique[idx] = a
+		} else {
+			unique = append(unique, a)
+			(*record)[a.Key] = len(unique) - 1
+		}
 	}
-	return s.attributes.toKeyValue()
+	// s.attributes have element types of attribute.KeyValue. These types are
+	// not pointers and they themselves do not contain pointer fields,
+	// therefore the duplicate values do not need to be zeroed for them to be
+	// garbage collected.
+	s.attributes = unique
 }

 // Links returns the links of this span.
@ -440,7 +536,7 @@ func (s *recordingSpan) Status() Status {
 func (s *recordingSpan) InstrumentationLibrary() instrumentation.Library {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	return s.instrumentationLibrary
+	return s.tracer.instrumentationLibrary
 }

 // Resource returns the Resource associated with the Tracer that created this
@ -448,7 +544,7 @@ func (s *recordingSpan) InstrumentationLibrary() instrumentation.Library {
 func (s *recordingSpan) Resource() *resource.Resource {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	return s.resource
+	return s.tracer.provider.resource
 }

 func (s *recordingSpan) addLink(link trace.Link) {
@ -461,9 +557,9 @@ func (s *recordingSpan) addLink(link trace.Link) {
 	var droppedAttributeCount int

 	// Discard over limited attributes
-	if len(link.Attributes) > s.spanLimits.AttributePerLinkCountLimit {
-		droppedAttributeCount = len(link.Attributes) - s.spanLimits.AttributePerLinkCountLimit
-		link.Attributes = link.Attributes[:s.spanLimits.AttributePerLinkCountLimit]
+	if len(link.Attributes) > s.tracer.provider.spanLimits.AttributePerLinkCountLimit {
+		droppedAttributeCount = len(link.Attributes) - s.tracer.provider.spanLimits.AttributePerLinkCountLimit
+		link.Attributes = link.Attributes[:s.tracer.provider.spanLimits.AttributePerLinkCountLimit]
 	}

 	s.links.add(Link{link.SpanContext, link.Attributes, droppedAttributeCount})
@ -474,7 +570,7 @@ func (s *recordingSpan) addLink(link trace.Link) {
 func (s *recordingSpan) DroppedAttributes() int {
 	s.mu.Lock()
 	defer s.mu.Unlock()
-	return s.attributes.droppedCount
+	return s.droppedAttributes
 }

 // DroppedLinks returns the number of links dropped by the span due to limits
@ -514,20 +610,21 @@ func (s *recordingSpan) snapshot() ReadOnlySpan {
 	defer s.mu.Unlock()

 	sd.endTime = s.endTime
-	sd.instrumentationLibrary = s.instrumentationLibrary
+	sd.instrumentationLibrary = s.tracer.instrumentationLibrary
 	sd.name = s.name
 	sd.parent = s.parent
-	sd.resource = s.resource
+	sd.resource = s.tracer.provider.resource
 	sd.spanContext = s.spanContext
 	sd.spanKind = s.spanKind
 	sd.startTime = s.startTime
 	sd.status = s.status
 	sd.childSpanCount = s.childSpanCount

-	if s.attributes.evictList.Len() > 0 {
-		sd.attributes = s.attributes.toKeyValue()
-		sd.droppedAttributeCount = s.attributes.droppedCount
+	if len(s.attributes) > 0 {
+		s.dedupeAttrs()
+		sd.attributes = s.attributes
 	}
+	sd.droppedAttributeCount = s.droppedAttributes
 	if len(s.events.queue) > 0 {
 		sd.events = s.interfaceArrayToEventArray()
 		sd.droppedEventCount = s.events.droppedCount
@ -555,18 +652,6 @@ func (s *recordingSpan) interfaceArrayToEventArray() []Event {
 	return eventArr
 }

-func (s *recordingSpan) copyToCappedAttributes(attributes ...attribute.KeyValue) {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-	for _, a := range attributes {
-		// Ensure attributes conform to the specification:
-		// https://github.com/open-telemetry/opentelemetry-specification/blob/v1.0.1/specification/common/common.md#attributes
-		if a.Valid() {
-			s.attributes.add(a)
-		}
-	}
-}
-
 func (s *recordingSpan) addChild() {
 	if !s.IsRecording() {
 		return
--- a/vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go
+++ b/vendor/go.opentelemetry.io/otel/sdk/trace/tracer.go
@ -122,18 +122,22 @@ func (tr *tracer) newRecordingSpan(psc, sc trace.SpanContext, name string, sr Sa
 	}

 	s := &recordingSpan{
-		parent:                 psc,
-		spanContext:            sc,
-		spanKind:               trace.ValidateSpanKind(config.SpanKind()),
-		name:                   name,
-		startTime:              startTime,
-		attributes:             newAttributesMap(tr.provider.spanLimits.AttributeCountLimit),
-		events:                 newEvictedQueue(tr.provider.spanLimits.EventCountLimit),
-		links:                  newEvictedQueue(tr.provider.spanLimits.LinkCountLimit),
-		tracer:                 tr,
-		spanLimits:             tr.provider.spanLimits,
-		resource:               tr.provider.resource,
-		instrumentationLibrary: tr.instrumentationLibrary,
+		// Do not pre-allocate the attributes slice here! Doing so will
+		// allocate memory that is likely never going to be used, or if used,
+		// will be over-sized. The default Go compiler has been tested to
+		// dynamically allocate needed space very well. Benchmarking has shown
+		// it to be more performant than what we can predetermine here,
+		// especially for the common use case of few to no added
+		// attributes.
+
+		parent:      psc,
+		spanContext: sc,
+		spanKind:    trace.ValidateSpanKind(config.SpanKind()),
+		name:        name,
+		startTime:   startTime,
+		events:      newEvictedQueue(tr.provider.spanLimits.EventCountLimit),
+		links:       newEvictedQueue(tr.provider.spanLimits.LinkCountLimit),
+		tracer:      tr,
 	}

 	for _, l := range config.Links() {
--- a/vendor/go.opentelemetry.io/otel/tag.sh
+++ b/vendor/go.opentelemetry.io/otel/tag.sh
@ -1,178 +0,0 @@
-#!/usr/bin/env bash
-
-# 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.
-
-readonly PROGNAME=$(basename "$0")
-readonly PROGDIR=$(readlink -m "$(dirname "$0")")
-
-readonly EXCLUDE_PACKAGES="internal/tools"
-readonly SEMVER_REGEX="v(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(\\-[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?(\\+[0-9A-Za-z-]+(\\.[0-9A-Za-z-]+)*)?"
-
-usage() {
-    cat <<- EOF
-Usage: $PROGNAME [OPTIONS] SEMVER_TAG COMMIT_HASH
-
-Creates git tag for all Go packages in project.
-
-OPTIONS:
-  -h --help        Show this help.
-
-ARGUMENTS:
-  SEMVER_TAG       Semantic version to tag with.
-  COMMIT_HASH      Git commit hash to tag.
-EOF
-}
-
-cmdline() {
-    local arg commit
-
-    for arg
-    do
-        local delim=""
-        case "$arg" in
-            # Translate long form options to short form.
-            --help)           args="${args}-h ";;
-            # Pass through for everything else.
-            *) [[ "${arg:0:1}" == "-" ]] || delim="\""
-                args="${args}${delim}${arg}${delim} ";;
-        esac
-    done
-
-    # Reset and process short form options.
-    eval set -- "$args"
-
-    while getopts "h" OPTION
-    do
-         case $OPTION in
-         h)
-             usage
-             exit 0
-             ;;
-         *)
-             echo "unknown option: $OPTION"
-             usage
-             exit 1
-             ;;
-        esac
-    done
-
-    # Positional arguments.
-    shift $((OPTIND-1))
-    readonly TAG="$1"
-    if [ -z "$TAG" ]
-    then
-        echo "missing SEMVER_TAG"
-        usage
-        exit 1
-    fi
-    if [[ ! "$TAG" =~ $SEMVER_REGEX ]]
-    then
-        printf "invalid semantic version: %s\n" "$TAG"
-        exit 2
-    fi
-    if [[ "$( git tag --list "$TAG" )" ]]
-    then
-        printf "tag already exists: %s\n" "$TAG"
-        exit 2
-    fi
-
-    shift
-    commit="$1"
-    if [ -z "$commit" ]
-    then
-        echo "missing COMMIT_HASH"
-        usage
-        exit 1
-    fi
-    # Verify rev is for a commit and unify hashes into a complete SHA1.
-    readonly SHA="$( git rev-parse --quiet --verify "${commit}^{commit}" )"
-    if [ -z "$SHA" ]
-    then
-        printf "invalid commit hash: %s\n" "$commit"
-        exit 2
-    fi
-    if [ "$( git merge-base "$SHA" HEAD )" != "$SHA" ]
-    then
-        printf "commit '%s' not found on this branch\n" "$commit"
-        exit 2
-    fi
-}
-
-package_dirs() {
-    # Return a list of package directories in the form:
-    #
-    #  package/directory/a
-    #  package/directory/b
-    #  deeper/package/directory/a
-    #  ...
-    #
-    # Making sure to exclude any packages in the EXCLUDE_PACKAGES regexp.
-    find . -mindepth 2 -type f -name 'go.mod' -exec dirname {} \; \
-        | grep -E -v "$EXCLUDE_PACKAGES" \
-        | sed 's/^\.\///' \
-        | sort
-}
-
-git_tag() {
-    local tag="$1"
-    local commit="$2"
-
-    git tag -a "$tag" -s -m "Version $tag" "$commit"
-}
-
-previous_version() {
-    local current="$1"
-
-    # Requires git > 2.0
-    git tag -l --sort=v:refname \
-        | grep -E "^${SEMVER_REGEX}$" \
-        | grep -v "$current" \
-        | tail -1
-}
-
-print_changes() {
-    local tag="$1"
-    local previous
-
-    previous="$( previous_version "$tag" )"
-    if [ -n "$previous" ]
-    then
-        printf "\nRaw changes made between %s and %s\n" "$previous" "$tag"
-        printf "======================================\n"
-        git --no-pager log --pretty=oneline "${previous}..$tag"
-    fi
-}
-
-main() {
-    local dir
-
-    cmdline "$@"
-
-    cd "$PROGDIR" || exit 3
-
-    # Create tag for root package.
-    git_tag "$TAG" "$SHA"
-    printf "created tag: %s\n" "$TAG"
-
-    # Create tag for all sub-packages.
-    for dir in $( package_dirs )
-    do
-        git_tag "${dir}/$TAG" "$SHA"
-        printf "created tag: %s\n" "${dir}/$TAG"
-    done
-
-    print_changes "$TAG"
-}
-main "$@"
--- a/vendor/go.opentelemetry.io/otel/trace/config.go
+++ b/vendor/go.opentelemetry.io/otel/trace/config.go
@ -41,20 +41,20 @@ func (t *TracerConfig) SchemaURL() string {
 func NewTracerConfig(options ...TracerOption) TracerConfig {
 	var config TracerConfig
 	for _, option := range options {
-		option.apply(&config)
+		config = option.apply(config)
 	}
 	return config
 }

 // TracerOption applies an option to a TracerConfig.
 type TracerOption interface {
-	apply(*TracerConfig)
+	apply(TracerConfig) TracerConfig
 }

-type tracerOptionFunc func(*TracerConfig)
+type tracerOptionFunc func(TracerConfig) TracerConfig

-func (fn tracerOptionFunc) apply(cfg *TracerConfig) {
-	fn(cfg)
+func (fn tracerOptionFunc) apply(cfg TracerConfig) TracerConfig {
+	return fn(cfg)
 }

 // SpanConfig is a group of options for a Span.
@ -106,7 +106,7 @@ func (cfg *SpanConfig) SpanKind() SpanKind {
 func NewSpanStartConfig(options ...SpanStartOption) SpanConfig {
 	var c SpanConfig
 	for _, option := range options {
-		option.applySpanStart(&c)
+		c = option.applySpanStart(c)
 	}
 	return c
 }
@ -118,7 +118,7 @@ func NewSpanStartConfig(options ...SpanStartOption) SpanConfig {
 func NewSpanEndConfig(options ...SpanEndOption) SpanConfig {
 	var c SpanConfig
 	for _, option := range options {
-		option.applySpanEnd(&c)
+		c = option.applySpanEnd(c)
 	}
 	return c
 }
@ -126,19 +126,19 @@ func NewSpanEndConfig(options ...SpanEndOption) SpanConfig {
 // SpanStartOption applies an option to a SpanConfig. These options are applicable
 // only when the span is created
 type SpanStartOption interface {
-	applySpanStart(*SpanConfig)
+	applySpanStart(SpanConfig) SpanConfig
 }

-type spanOptionFunc func(*SpanConfig)
+type spanOptionFunc func(SpanConfig) SpanConfig

-func (fn spanOptionFunc) applySpanStart(cfg *SpanConfig) {
-	fn(cfg)
+func (fn spanOptionFunc) applySpanStart(cfg SpanConfig) SpanConfig {
+	return fn(cfg)
 }

 // SpanEndOption applies an option to a SpanConfig. These options are
 // applicable only when the span is ended.
 type SpanEndOption interface {
-	applySpanEnd(*SpanConfig)
+	applySpanEnd(SpanConfig) SpanConfig
 }

 // EventConfig is a group of options for an Event.
@ -170,7 +170,7 @@ func (cfg *EventConfig) StackTrace() bool {
 func NewEventConfig(options ...EventOption) EventConfig {
 	var c EventConfig
 	for _, option := range options {
-		option.applyEvent(&c)
+		c = option.applyEvent(c)
 	}
 	if c.timestamp.IsZero() {
 		c.timestamp = time.Now()
@ -180,7 +180,7 @@ func NewEventConfig(options ...EventOption) EventConfig {

 // EventOption applies span event options to an EventConfig.
 type EventOption interface {
-	applyEvent(*EventConfig)
+	applyEvent(EventConfig) EventConfig
 }

 // SpanOption are options that can be used at both the beginning and end of a span.
@ -203,12 +203,14 @@ type SpanEndEventOption interface {

 type attributeOption []attribute.KeyValue

-func (o attributeOption) applySpan(c *SpanConfig) {
+func (o attributeOption) applySpan(c SpanConfig) SpanConfig {
 	c.attributes = append(c.attributes, []attribute.KeyValue(o)...)
+	return c
 }
-func (o attributeOption) applySpanStart(c *SpanConfig) { o.applySpan(c) }
-func (o attributeOption) applyEvent(c *EventConfig) {
+func (o attributeOption) applySpanStart(c SpanConfig) SpanConfig { return o.applySpan(c) }
+func (o attributeOption) applyEvent(c EventConfig) EventConfig {
 	c.attributes = append(c.attributes, []attribute.KeyValue(o)...)
+	return c
 }

 var _ SpanStartEventOption = attributeOption{}
@ -234,10 +236,16 @@ type SpanEventOption interface {

 type timestampOption time.Time

-func (o timestampOption) applySpan(c *SpanConfig)      { c.timestamp = time.Time(o) }
-func (o timestampOption) applySpanStart(c *SpanConfig) { o.applySpan(c) }
-func (o timestampOption) applySpanEnd(c *SpanConfig)   { o.applySpan(c) }
-func (o timestampOption) applyEvent(c *EventConfig)    { c.timestamp = time.Time(o) }
+func (o timestampOption) applySpan(c SpanConfig) SpanConfig {
+	c.timestamp = time.Time(o)
+	return c
+}
+func (o timestampOption) applySpanStart(c SpanConfig) SpanConfig { return o.applySpan(c) }
+func (o timestampOption) applySpanEnd(c SpanConfig) SpanConfig   { return o.applySpan(c) }
+func (o timestampOption) applyEvent(c EventConfig) EventConfig {
+	c.timestamp = time.Time(o)
+	return c
+}

 var _ SpanEventOption = timestampOption{}

@ -249,9 +257,15 @@ func WithTimestamp(t time.Time) SpanEventOption {

 type stackTraceOption bool

-func (o stackTraceOption) applyEvent(c *EventConfig)  { c.stackTrace = bool(o) }
-func (o stackTraceOption) applySpan(c *SpanConfig)    { c.stackTrace = bool(o) }
-func (o stackTraceOption) applySpanEnd(c *SpanConfig) { o.applySpan(c) }
+func (o stackTraceOption) applyEvent(c EventConfig) EventConfig {
+	c.stackTrace = bool(o)
+	return c
+}
+func (o stackTraceOption) applySpan(c SpanConfig) SpanConfig {
+	c.stackTrace = bool(o)
+	return c
+}
+func (o stackTraceOption) applySpanEnd(c SpanConfig) SpanConfig { return o.applySpan(c) }

 // WithStackTrace sets the flag to capture the error with stack trace (e.g. true, false).
 func WithStackTrace(b bool) SpanEndEventOption {
@ -261,8 +275,9 @@ func WithStackTrace(b bool) SpanEndEventOption {
 // WithLinks adds links to a Span. The links are added to the existing Span
 // links, i.e. this does not overwrite. Links with invalid span context are ignored.
 func WithLinks(links ...Link) SpanStartOption {
-	return spanOptionFunc(func(cfg *SpanConfig) {
+	return spanOptionFunc(func(cfg SpanConfig) SpanConfig {
 		cfg.links = append(cfg.links, links...)
+		return cfg
 	})
 }

@ -270,28 +285,32 @@ func WithLinks(links ...Link) SpanStartOption {
 // existing parent span context will be ignored when defining the Span's trace
 // identifiers.
 func WithNewRoot() SpanStartOption {
-	return spanOptionFunc(func(cfg *SpanConfig) {
+	return spanOptionFunc(func(cfg SpanConfig) SpanConfig {
 		cfg.newRoot = true
+		return cfg
 	})
 }

 // WithSpanKind sets the SpanKind of a Span.
 func WithSpanKind(kind SpanKind) SpanStartOption {
-	return spanOptionFunc(func(cfg *SpanConfig) {
+	return spanOptionFunc(func(cfg SpanConfig) SpanConfig {
 		cfg.spanKind = kind
+		return cfg
 	})
 }

 // WithInstrumentationVersion sets the instrumentation version.
 func WithInstrumentationVersion(version string) TracerOption {
-	return tracerOptionFunc(func(cfg *TracerConfig) {
+	return tracerOptionFunc(func(cfg TracerConfig) TracerConfig {
 		cfg.instrumentationVersion = version
+		return cfg
 	})
 }

 // WithSchemaURL sets the schema URL for the Tracer.
 func WithSchemaURL(schemaURL string) TracerOption {
-	return tracerOptionFunc(func(cfg *TracerConfig) {
+	return tracerOptionFunc(func(cfg TracerConfig) TracerConfig {
 		cfg.schemaURL = schemaURL
+		return cfg
 	})
 }
--- a/vendor/go.opentelemetry.io/otel/trace/tracestate.go
+++ b/vendor/go.opentelemetry.io/otel/trace/tracestate.go
@ -58,7 +58,7 @@ func newMember(key, value string) (member, error) {
 	return member{Key: key, Value: value}, nil
 }

-func parseMemeber(m string) (member, error) {
+func parseMember(m string) (member, error) {
 	matches := memberRe.FindStringSubmatch(m)
 	if len(matches) != 5 {
 		return member{}, fmt.Errorf("%w: %s", errInvalidMember, m)
@ -114,7 +114,7 @@ func ParseTraceState(tracestate string) (TraceState, error) {
 			continue
 		}

-		m, err := parseMemeber(memberStr)
+		m, err := parseMember(memberStr)
 		if err != nil {
 			return TraceState{}, wrapErr(err)
 		}
--- a/vendor/go.opentelemetry.io/otel/version.go
+++ b/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.3.0"
+	return "1.4.0"
 }
--- a/vendor/go.opentelemetry.io/otel/versions.yaml
+++ b/vendor/go.opentelemetry.io/otel/versions.yaml
@ -14,7 +14,7 @@

 module-sets:
  stable-v1:
-    version: v1.3.0
+    version: v1.4.0
    modules:
      - go.opentelemetry.io/otel
      - go.opentelemetry.io/otel/bridge/opentracing
@ -34,7 +34,7 @@ module-sets:
      - go.opentelemetry.io/otel/trace
      - go.opentelemetry.io/otel/sdk
  experimental-metrics:
-    version: v0.26.0
+    version: v0.27.0
    modules:
      - go.opentelemetry.io/otel/example/prometheus
      - go.opentelemetry.io/otel/exporters/otlp/otlpmetric
@ -47,11 +47,11 @@ module-sets:
      - go.opentelemetry.io/otel/sdk/export/metric
      - go.opentelemetry.io/otel/sdk/metric
  experimental-schema:
-    version: v0.0.1
+    version: v0.0.2
    modules:
      - go.opentelemetry.io/otel/schema
  bridge:
-    version: v0.26.0
+    version: v0.27.0
    modules:
      - go.opentelemetry.io/otel/bridge/opencensus
      - go.opentelemetry.io/otel/bridge/opencensus/test
--- a/vendor/go.opentelemetry.io/proto/otlp/trace/v1/trace.pb.go
+++ b/vendor/go.opentelemetry.io/proto/otlp/trace/v1/trace.pb.go
@ -115,97 +115,6 @@ func (Span_SpanKind) EnumDescriptor() ([]byte, []int) {
 	return file_opentelemetry_proto_trace_v1_trace_proto_rawDescGZIP(), []int{3, 0}
 }

-type Status_DeprecatedStatusCode int32
-
-const (
-	Status_DEPRECATED_STATUS_CODE_OK                  Status_DeprecatedStatusCode = 0
-	Status_DEPRECATED_STATUS_CODE_CANCELLED           Status_DeprecatedStatusCode = 1
-	Status_DEPRECATED_STATUS_CODE_UNKNOWN_ERROR       Status_DeprecatedStatusCode = 2
-	Status_DEPRECATED_STATUS_CODE_INVALID_ARGUMENT    Status_DeprecatedStatusCode = 3
-	Status_DEPRECATED_STATUS_CODE_DEADLINE_EXCEEDED   Status_DeprecatedStatusCode = 4
-	Status_DEPRECATED_STATUS_CODE_NOT_FOUND           Status_DeprecatedStatusCode = 5
-	Status_DEPRECATED_STATUS_CODE_ALREADY_EXISTS      Status_DeprecatedStatusCode = 6
-	Status_DEPRECATED_STATUS_CODE_PERMISSION_DENIED   Status_DeprecatedStatusCode = 7
-	Status_DEPRECATED_STATUS_CODE_RESOURCE_EXHAUSTED  Status_DeprecatedStatusCode = 8
-	Status_DEPRECATED_STATUS_CODE_FAILED_PRECONDITION Status_DeprecatedStatusCode = 9
-	Status_DEPRECATED_STATUS_CODE_ABORTED             Status_DeprecatedStatusCode = 10
-	Status_DEPRECATED_STATUS_CODE_OUT_OF_RANGE        Status_DeprecatedStatusCode = 11
-	Status_DEPRECATED_STATUS_CODE_UNIMPLEMENTED       Status_DeprecatedStatusCode = 12
-	Status_DEPRECATED_STATUS_CODE_INTERNAL_ERROR      Status_DeprecatedStatusCode = 13
-	Status_DEPRECATED_STATUS_CODE_UNAVAILABLE         Status_DeprecatedStatusCode = 14
-	Status_DEPRECATED_STATUS_CODE_DATA_LOSS           Status_DeprecatedStatusCode = 15
-	Status_DEPRECATED_STATUS_CODE_UNAUTHENTICATED     Status_DeprecatedStatusCode = 16
-)
-
-// Enum value maps for Status_DeprecatedStatusCode.
-var (
-	Status_DeprecatedStatusCode_name = map[int32]string{
-		0:  "DEPRECATED_STATUS_CODE_OK",
-		1:  "DEPRECATED_STATUS_CODE_CANCELLED",
-		2:  "DEPRECATED_STATUS_CODE_UNKNOWN_ERROR",
-		3:  "DEPRECATED_STATUS_CODE_INVALID_ARGUMENT",
-		4:  "DEPRECATED_STATUS_CODE_DEADLINE_EXCEEDED",
-		5:  "DEPRECATED_STATUS_CODE_NOT_FOUND",
-		6:  "DEPRECATED_STATUS_CODE_ALREADY_EXISTS",
-		7:  "DEPRECATED_STATUS_CODE_PERMISSION_DENIED",
-		8:  "DEPRECATED_STATUS_CODE_RESOURCE_EXHAUSTED",
-		9:  "DEPRECATED_STATUS_CODE_FAILED_PRECONDITION",
-		10: "DEPRECATED_STATUS_CODE_ABORTED",
-		11: "DEPRECATED_STATUS_CODE_OUT_OF_RANGE",
-		12: "DEPRECATED_STATUS_CODE_UNIMPLEMENTED",
-		13: "DEPRECATED_STATUS_CODE_INTERNAL_ERROR",
-		14: "DEPRECATED_STATUS_CODE_UNAVAILABLE",
-		15: "DEPRECATED_STATUS_CODE_DATA_LOSS",
-		16: "DEPRECATED_STATUS_CODE_UNAUTHENTICATED",
-	}
-	Status_DeprecatedStatusCode_value = map[string]int32{
-		"DEPRECATED_STATUS_CODE_OK":                  0,
-		"DEPRECATED_STATUS_CODE_CANCELLED":           1,
-		"DEPRECATED_STATUS_CODE_UNKNOWN_ERROR":       2,
-		"DEPRECATED_STATUS_CODE_INVALID_ARGUMENT":    3,
-		"DEPRECATED_STATUS_CODE_DEADLINE_EXCEEDED":   4,
-		"DEPRECATED_STATUS_CODE_NOT_FOUND":           5,
-		"DEPRECATED_STATUS_CODE_ALREADY_EXISTS":      6,
-		"DEPRECATED_STATUS_CODE_PERMISSION_DENIED":   7,
-		"DEPRECATED_STATUS_CODE_RESOURCE_EXHAUSTED":  8,
-		"DEPRECATED_STATUS_CODE_FAILED_PRECONDITION": 9,
-		"DEPRECATED_STATUS_CODE_ABORTED":             10,
-		"DEPRECATED_STATUS_CODE_OUT_OF_RANGE":        11,
-		"DEPRECATED_STATUS_CODE_UNIMPLEMENTED":       12,
-		"DEPRECATED_STATUS_CODE_INTERNAL_ERROR":      13,
-		"DEPRECATED_STATUS_CODE_UNAVAILABLE":         14,
-		"DEPRECATED_STATUS_CODE_DATA_LOSS":           15,
-		"DEPRECATED_STATUS_CODE_UNAUTHENTICATED":     16,
-	}
-)
-
-func (x Status_DeprecatedStatusCode) Enum() *Status_DeprecatedStatusCode {
-	p := new(Status_DeprecatedStatusCode)
-	*p = x
-	return p
-}
-
-func (x Status_DeprecatedStatusCode) String() string {
-	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
-}
-
-func (Status_DeprecatedStatusCode) Descriptor() protoreflect.EnumDescriptor {
-	return file_opentelemetry_proto_trace_v1_trace_proto_enumTypes[1].Descriptor()
-}
-
-func (Status_DeprecatedStatusCode) Type() protoreflect.EnumType {
-	return &file_opentelemetry_proto_trace_v1_trace_proto_enumTypes[1]
-}
-
-func (x Status_DeprecatedStatusCode) Number() protoreflect.EnumNumber {
-	return protoreflect.EnumNumber(x)
-}
-
-// Deprecated: Use Status_DeprecatedStatusCode.Descriptor instead.
-func (Status_DeprecatedStatusCode) EnumDescriptor() ([]byte, []int) {
-	return file_opentelemetry_proto_trace_v1_trace_proto_rawDescGZIP(), []int{4, 0}
-}
-
 // For the semantics of status codes see
 // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/api.md#set-status
 type Status_StatusCode int32
@ -245,11 +154,11 @@ func (x Status_StatusCode) String() string {
 }

 func (Status_StatusCode) Descriptor() protoreflect.EnumDescriptor {
-	return file_opentelemetry_proto_trace_v1_trace_proto_enumTypes[2].Descriptor()
+	return file_opentelemetry_proto_trace_v1_trace_proto_enumTypes[1].Descriptor()
 }

 func (Status_StatusCode) Type() protoreflect.EnumType {
-	return &file_opentelemetry_proto_trace_v1_trace_proto_enumTypes[2]
+	return &file_opentelemetry_proto_trace_v1_trace_proto_enumTypes[1]
 }

 func (x Status_StatusCode) Number() protoreflect.EnumNumber {
@ -258,7 +167,7 @@ func (x Status_StatusCode) Number() protoreflect.EnumNumber {

 // Deprecated: Use Status_StatusCode.Descriptor instead.
 func (Status_StatusCode) EnumDescriptor() ([]byte, []int) {
-	return file_opentelemetry_proto_trace_v1_trace_proto_rawDescGZIP(), []int{4, 1}
+	return file_opentelemetry_proto_trace_v1_trace_proto_rawDescGZIP(), []int{4, 0}
 }

 // TracesData represents the traces data that can be stored in a persistent storage,
@ -706,15 +615,6 @@ type Status struct {
 	sizeCache     protoimpl.SizeCache
 	unknownFields protoimpl.UnknownFields

-	// The deprecated status code. This is an optional field.
-	//
-	// This field is deprecated and is replaced by the `code` field below. See backward
-	// compatibility notes below. According to our stability guarantees this field
-	// will be removed in 12 months, on Oct 22, 2021. All usage of old senders and
-	// receivers that do not understand the `code` field MUST be phased out by then.
-	//
-	// Deprecated: Do not use.
-	DeprecatedCode Status_DeprecatedStatusCode `protobuf:"varint,1,opt,name=deprecated_code,json=deprecatedCode,proto3,enum=opentelemetry.proto.trace.v1.Status_DeprecatedStatusCode" json:"deprecated_code,omitempty"`
 	// A developer-facing human readable error message.
 	Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
 	// The status code.
@ -753,14 +653,6 @@ func (*Status) Descriptor() ([]byte, []int) {
 	return file_opentelemetry_proto_trace_v1_trace_proto_rawDescGZIP(), []int{4}
 }

-// Deprecated: Do not use.
-func (x *Status) GetDeprecatedCode() Status_DeprecatedStatusCode {
-	if x != nil {
-		return x.DeprecatedCode
-	}
-	return Status_DEPRECATED_STATUS_CODE_OK
-}
-
 func (x *Status) GetMessage() string {
 	if x != nil {
 		return x.Message
@ -1075,77 +967,25 @@ var file_opentelemetry_proto_trace_v1_trace_proto_rawDesc = []byte{
 	0x45, 0x4e, 0x54, 0x10, 0x03, 0x12, 0x16, 0x0a, 0x12, 0x53, 0x50, 0x41, 0x4e, 0x5f, 0x4b, 0x49,
 	0x4e, 0x44, 0x5f, 0x50, 0x52, 0x4f, 0x44, 0x55, 0x43, 0x45, 0x52, 0x10, 0x04, 0x12, 0x16, 0x0a,
 	0x12, 0x53, 0x50, 0x41, 0x4e, 0x5f, 0x4b, 0x49, 0x4e, 0x44, 0x5f, 0x43, 0x4f, 0x4e, 0x53, 0x55,
-	0x4d, 0x45, 0x52, 0x10, 0x05, 0x22, 0xfc, 0x07, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
-	0x12, 0x66, 0x0a, 0x0f, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x5f, 0x63,
-	0x6f, 0x64, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x39, 0x2e, 0x6f, 0x70, 0x65, 0x6e,
-	0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
-	0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e,
-	0x44, 0x65, 0x70, 0x72, 0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
-	0x43, 0x6f, 0x64, 0x65, 0x42, 0x02, 0x18, 0x01, 0x52, 0x0e, 0x64, 0x65, 0x70, 0x72, 0x65, 0x63,
-	0x61, 0x74, 0x65, 0x64, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73,
-	0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x12, 0x43, 0x0a, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e,
-	0x32, 0x2f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79,
-	0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e,
-	0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64,
-	0x65, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x22, 0xda, 0x05, 0x0a, 0x14, 0x44, 0x65, 0x70, 0x72,
-	0x65, 0x63, 0x61, 0x74, 0x65, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65,
-	0x12, 0x1d, 0x0a, 0x19, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53,
-	0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x4f, 0x4b, 0x10, 0x00, 0x12,
-	0x24, 0x0a, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54,
-	0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x43, 0x41, 0x4e, 0x43, 0x45, 0x4c,
-	0x4c, 0x45, 0x44, 0x10, 0x01, 0x12, 0x28, 0x0a, 0x24, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41,
-	0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f,
-	0x55, 0x4e, 0x4b, 0x4e, 0x4f, 0x57, 0x4e, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x02, 0x12,
-	0x2b, 0x0a, 0x27, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54,
-	0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x49, 0x4e, 0x56, 0x41, 0x4c, 0x49,
-	0x44, 0x5f, 0x41, 0x52, 0x47, 0x55, 0x4d, 0x45, 0x4e, 0x54, 0x10, 0x03, 0x12, 0x2c, 0x0a, 0x28,
-	0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55,
-	0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x44, 0x45, 0x41, 0x44, 0x4c, 0x49, 0x4e, 0x45, 0x5f,
-	0x45, 0x58, 0x43, 0x45, 0x45, 0x44, 0x45, 0x44, 0x10, 0x04, 0x12, 0x24, 0x0a, 0x20, 0x44, 0x45,
-	0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f,
-	0x43, 0x4f, 0x44, 0x45, 0x5f, 0x4e, 0x4f, 0x54, 0x5f, 0x46, 0x4f, 0x55, 0x4e, 0x44, 0x10, 0x05,
-	0x12, 0x29, 0x0a, 0x25, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53,
-	0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x41, 0x4c, 0x52, 0x45, 0x41,
-	0x44, 0x59, 0x5f, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x10, 0x06, 0x12, 0x2c, 0x0a, 0x28, 0x44,
-	0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53,
-	0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x50, 0x45, 0x52, 0x4d, 0x49, 0x53, 0x53, 0x49, 0x4f, 0x4e,
-	0x5f, 0x44, 0x45, 0x4e, 0x49, 0x45, 0x44, 0x10, 0x07, 0x12, 0x2d, 0x0a, 0x29, 0x44, 0x45, 0x50,
-	0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43,
-	0x4f, 0x44, 0x45, 0x5f, 0x52, 0x45, 0x53, 0x4f, 0x55, 0x52, 0x43, 0x45, 0x5f, 0x45, 0x58, 0x48,
-	0x41, 0x55, 0x53, 0x54, 0x45, 0x44, 0x10, 0x08, 0x12, 0x2e, 0x0a, 0x2a, 0x44, 0x45, 0x50, 0x52,
-	0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f,
-	0x44, 0x45, 0x5f, 0x46, 0x41, 0x49, 0x4c, 0x45, 0x44, 0x5f, 0x50, 0x52, 0x45, 0x43, 0x4f, 0x4e,
-	0x44, 0x49, 0x54, 0x49, 0x4f, 0x4e, 0x10, 0x09, 0x12, 0x22, 0x0a, 0x1e, 0x44, 0x45, 0x50, 0x52,
-	0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f,
-	0x44, 0x45, 0x5f, 0x41, 0x42, 0x4f, 0x52, 0x54, 0x45, 0x44, 0x10, 0x0a, 0x12, 0x27, 0x0a, 0x23,
-	0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55,
-	0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x4f, 0x55, 0x54, 0x5f, 0x4f, 0x46, 0x5f, 0x52, 0x41,
-	0x4e, 0x47, 0x45, 0x10, 0x0b, 0x12, 0x28, 0x0a, 0x24, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41,
-	0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f,
-	0x55, 0x4e, 0x49, 0x4d, 0x50, 0x4c, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x45, 0x44, 0x10, 0x0c, 0x12,
-	0x29, 0x0a, 0x25, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54,
-	0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x4e,
-	0x41, 0x4c, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x0d, 0x12, 0x26, 0x0a, 0x22, 0x44, 0x45,
-	0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f,
-	0x43, 0x4f, 0x44, 0x45, 0x5f, 0x55, 0x4e, 0x41, 0x56, 0x41, 0x49, 0x4c, 0x41, 0x42, 0x4c, 0x45,
-	0x10, 0x0e, 0x12, 0x24, 0x0a, 0x20, 0x44, 0x45, 0x50, 0x52, 0x45, 0x43, 0x41, 0x54, 0x45, 0x44,
-	0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x44, 0x41, 0x54,
-	0x41, 0x5f, 0x4c, 0x4f, 0x53, 0x53, 0x10, 0x0f, 0x12, 0x2a, 0x0a, 0x26, 0x44, 0x45, 0x50, 0x52,
-	0x45, 0x43, 0x41, 0x54, 0x45, 0x44, 0x5f, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f,
-	0x44, 0x45, 0x5f, 0x55, 0x4e, 0x41, 0x55, 0x54, 0x48, 0x45, 0x4e, 0x54, 0x49, 0x43, 0x41, 0x54,
-	0x45, 0x44, 0x10, 0x10, 0x22, 0x4e, 0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f,
-	0x64, 0x65, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44,
-	0x45, 0x5f, 0x55, 0x4e, 0x53, 0x45, 0x54, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x53, 0x54, 0x41,
-	0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x4f, 0x4b, 0x10, 0x01, 0x12, 0x15, 0x0a,
-	0x11, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x45, 0x52, 0x52,
-	0x4f, 0x52, 0x10, 0x02, 0x42, 0x58, 0x0a, 0x1f, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x74,
+	0x4d, 0x45, 0x52, 0x10, 0x05, 0x22, 0xbd, 0x01, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73,
+	0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x43, 0x0a, 0x04, 0x63, 0x6f,
+	0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x2f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x74,
 	0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x74,
-	0x72, 0x61, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x54, 0x72, 0x61, 0x63, 0x65, 0x50, 0x72,
-	0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x74, 0x65,
-	0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f,
-	0x2f, 0x6f, 0x74, 0x6c, 0x70, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06,
-	0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x72, 0x61, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x2e, 0x53,
+	0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x52, 0x04, 0x63, 0x6f, 0x64, 0x65, 0x22,
+	0x4e, 0x0a, 0x0a, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x43, 0x6f, 0x64, 0x65, 0x12, 0x15, 0x0a,
+	0x11, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x55, 0x4e, 0x53,
+	0x45, 0x54, 0x10, 0x00, 0x12, 0x12, 0x0a, 0x0e, 0x53, 0x54, 0x41, 0x54, 0x55, 0x53, 0x5f, 0x43,
+	0x4f, 0x44, 0x45, 0x5f, 0x4f, 0x4b, 0x10, 0x01, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x54, 0x41, 0x54,
+	0x55, 0x53, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x45, 0x52, 0x52, 0x4f, 0x52, 0x10, 0x02, 0x4a,
+	0x04, 0x08, 0x01, 0x10, 0x02, 0x42, 0x58, 0x0a, 0x1f, 0x69, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e,
+	0x74, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e,
+	0x74, 0x72, 0x61, 0x63, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x0a, 0x54, 0x72, 0x61, 0x63, 0x65, 0x50,
+	0x72, 0x6f, 0x74, 0x6f, 0x50, 0x01, 0x5a, 0x27, 0x67, 0x6f, 0x2e, 0x6f, 0x70, 0x65, 0x6e, 0x74,
+	0x65, 0x6c, 0x65, 0x6d, 0x65, 0x74, 0x72, 0x79, 0x2e, 0x69, 0x6f, 0x2f, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x2f, 0x6f, 0x74, 0x6c, 0x70, 0x2f, 0x74, 0x72, 0x61, 0x63, 0x65, 0x2f, 0x76, 0x31, 0x62,
+	0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 }

 var (
@ -1160,43 +1000,41 @@ func file_opentelemetry_proto_trace_v1_trace_proto_rawDescGZIP() []byte {
 	return file_opentelemetry_proto_trace_v1_trace_proto_rawDescData
 }

-var file_opentelemetry_proto_trace_v1_trace_proto_enumTypes = make([]protoimpl.EnumInfo, 3)
+var file_opentelemetry_proto_trace_v1_trace_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
 var file_opentelemetry_proto_trace_v1_trace_proto_msgTypes = make([]protoimpl.MessageInfo, 7)
 var file_opentelemetry_proto_trace_v1_trace_proto_goTypes = []interface{}{
 	(Span_SpanKind)(0),                  // 0: opentelemetry.proto.trace.v1.Span.SpanKind
-	(Status_DeprecatedStatusCode)(0),    // 1: opentelemetry.proto.trace.v1.Status.DeprecatedStatusCode
-	(Status_StatusCode)(0),              // 2: opentelemetry.proto.trace.v1.Status.StatusCode
-	(*TracesData)(nil),                  // 3: opentelemetry.proto.trace.v1.TracesData
-	(*ResourceSpans)(nil),               // 4: opentelemetry.proto.trace.v1.ResourceSpans
-	(*InstrumentationLibrarySpans)(nil), // 5: opentelemetry.proto.trace.v1.InstrumentationLibrarySpans
-	(*Span)(nil),                        // 6: opentelemetry.proto.trace.v1.Span
-	(*Status)(nil),                      // 7: opentelemetry.proto.trace.v1.Status
-	(*Span_Event)(nil),                  // 8: opentelemetry.proto.trace.v1.Span.Event
-	(*Span_Link)(nil),                   // 9: opentelemetry.proto.trace.v1.Span.Link
-	(*v1.Resource)(nil),                 // 10: opentelemetry.proto.resource.v1.Resource
-	(*v11.InstrumentationLibrary)(nil),  // 11: opentelemetry.proto.common.v1.InstrumentationLibrary
-	(*v11.KeyValue)(nil),                // 12: opentelemetry.proto.common.v1.KeyValue
+	(Status_StatusCode)(0),              // 1: opentelemetry.proto.trace.v1.Status.StatusCode
+	(*TracesData)(nil),                  // 2: opentelemetry.proto.trace.v1.TracesData
+	(*ResourceSpans)(nil),               // 3: opentelemetry.proto.trace.v1.ResourceSpans
+	(*InstrumentationLibrarySpans)(nil), // 4: opentelemetry.proto.trace.v1.InstrumentationLibrarySpans
+	(*Span)(nil),                        // 5: opentelemetry.proto.trace.v1.Span
+	(*Status)(nil),                      // 6: opentelemetry.proto.trace.v1.Status
+	(*Span_Event)(nil),                  // 7: opentelemetry.proto.trace.v1.Span.Event
+	(*Span_Link)(nil),                   // 8: opentelemetry.proto.trace.v1.Span.Link
+	(*v1.Resource)(nil),                 // 9: opentelemetry.proto.resource.v1.Resource
+	(*v11.InstrumentationLibrary)(nil),  // 10: opentelemetry.proto.common.v1.InstrumentationLibrary
+	(*v11.KeyValue)(nil),                // 11: opentelemetry.proto.common.v1.KeyValue
 }
 var file_opentelemetry_proto_trace_v1_trace_proto_depIdxs = []int32{
-	4,  // 0: opentelemetry.proto.trace.v1.TracesData.resource_spans:type_name -> opentelemetry.proto.trace.v1.ResourceSpans
-	10, // 1: opentelemetry.proto.trace.v1.ResourceSpans.resource:type_name -> opentelemetry.proto.resource.v1.Resource
-	5,  // 2: opentelemetry.proto.trace.v1.ResourceSpans.instrumentation_library_spans:type_name -> opentelemetry.proto.trace.v1.InstrumentationLibrarySpans
-	11, // 3: opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.instrumentation_library:type_name -> opentelemetry.proto.common.v1.InstrumentationLibrary
-	6,  // 4: opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.spans:type_name -> opentelemetry.proto.trace.v1.Span
+	3,  // 0: opentelemetry.proto.trace.v1.TracesData.resource_spans:type_name -> opentelemetry.proto.trace.v1.ResourceSpans
+	9,  // 1: opentelemetry.proto.trace.v1.ResourceSpans.resource:type_name -> opentelemetry.proto.resource.v1.Resource
+	4,  // 2: opentelemetry.proto.trace.v1.ResourceSpans.instrumentation_library_spans:type_name -> opentelemetry.proto.trace.v1.InstrumentationLibrarySpans
+	10, // 3: opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.instrumentation_library:type_name -> opentelemetry.proto.common.v1.InstrumentationLibrary
+	5,  // 4: opentelemetry.proto.trace.v1.InstrumentationLibrarySpans.spans:type_name -> opentelemetry.proto.trace.v1.Span
 	0,  // 5: opentelemetry.proto.trace.v1.Span.kind:type_name -> opentelemetry.proto.trace.v1.Span.SpanKind
-	12, // 6: opentelemetry.proto.trace.v1.Span.attributes:type_name -> opentelemetry.proto.common.v1.KeyValue
-	8,  // 7: opentelemetry.proto.trace.v1.Span.events:type_name -> opentelemetry.proto.trace.v1.Span.Event
-	9,  // 8: opentelemetry.proto.trace.v1.Span.links:type_name -> opentelemetry.proto.trace.v1.Span.Link
-	7,  // 9: opentelemetry.proto.trace.v1.Span.status:type_name -> opentelemetry.proto.trace.v1.Status
-	1,  // 10: opentelemetry.proto.trace.v1.Status.deprecated_code:type_name -> opentelemetry.proto.trace.v1.Status.DeprecatedStatusCode
-	2,  // 11: opentelemetry.proto.trace.v1.Status.code:type_name -> opentelemetry.proto.trace.v1.Status.StatusCode
-	12, // 12: opentelemetry.proto.trace.v1.Span.Event.attributes:type_name -> opentelemetry.proto.common.v1.KeyValue
-	12, // 13: opentelemetry.proto.trace.v1.Span.Link.attributes:type_name -> opentelemetry.proto.common.v1.KeyValue
-	14, // [14:14] is the sub-list for method output_type
-	14, // [14:14] is the sub-list for method input_type
-	14, // [14:14] is the sub-list for extension type_name
-	14, // [14:14] is the sub-list for extension extendee
-	0,  // [0:14] is the sub-list for field type_name
+	11, // 6: opentelemetry.proto.trace.v1.Span.attributes:type_name -> opentelemetry.proto.common.v1.KeyValue
+	7,  // 7: opentelemetry.proto.trace.v1.Span.events:type_name -> opentelemetry.proto.trace.v1.Span.Event
+	8,  // 8: opentelemetry.proto.trace.v1.Span.links:type_name -> opentelemetry.proto.trace.v1.Span.Link
+	6,  // 9: opentelemetry.proto.trace.v1.Span.status:type_name -> opentelemetry.proto.trace.v1.Status
+	1,  // 10: opentelemetry.proto.trace.v1.Status.code:type_name -> opentelemetry.proto.trace.v1.Status.StatusCode
+	11, // 11: opentelemetry.proto.trace.v1.Span.Event.attributes:type_name -> opentelemetry.proto.common.v1.KeyValue
+	11, // 12: opentelemetry.proto.trace.v1.Span.Link.attributes:type_name -> opentelemetry.proto.common.v1.KeyValue
+	13, // [13:13] is the sub-list for method output_type
+	13, // [13:13] is the sub-list for method input_type
+	13, // [13:13] is the sub-list for extension type_name
+	13, // [13:13] is the sub-list for extension extendee
+	0,  // [0:13] is the sub-list for field type_name
 }

 func init() { file_opentelemetry_proto_trace_v1_trace_proto_init() }
@ -1295,7 +1133,7 @@ func file_opentelemetry_proto_trace_v1_trace_proto_init() {
 		File: protoimpl.DescBuilder{
 			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
 			RawDescriptor: file_opentelemetry_proto_trace_v1_trace_proto_rawDesc,
-			NumEnums:      3,
+			NumEnums:      2,
 			NumMessages:   7,
 			NumExtensions: 0,
 			NumServices:   0,
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@ -318,8 +318,8 @@ github.com/golang/protobuf/ptypes/any
 github.com/golang/protobuf/ptypes/duration
 github.com/golang/protobuf/ptypes/timestamp
 github.com/golang/protobuf/ptypes/wrappers
-# github.com/google/go-cmp v0.5.6
-## explicit; go 1.8
+# github.com/google/go-cmp v0.5.7
+## explicit; go 1.11
 github.com/google/go-cmp/cmp
 github.com/google/go-cmp/cmp/internal/diff
 github.com/google/go-cmp/cmp/internal/flags
@ -499,17 +499,17 @@ go.opencensus.io/internal
 go.opencensus.io/trace
 go.opencensus.io/trace/internal
 go.opencensus.io/trace/tracestate
-# go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.28.0
+# go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.29.0
 ## explicit; go 1.16
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc/internal
-# go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.27.1-0.20211201163413-2bb24f926b80
+# go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace v0.29.0
 ## explicit; go 1.16
 go.opentelemetry.io/contrib/instrumentation/net/http/httptrace/otelhttptrace
-# go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.28.1-0.20220111222512-7e31ebe04030
+# go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.29.0
 ## explicit; go 1.16
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp
-# go.opentelemetry.io/otel v1.3.0
+# go.opentelemetry.io/otel v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel
 go.opentelemetry.io/otel/attribute
@ -520,48 +520,49 @@ go.opentelemetry.io/otel/internal/baggage
 go.opentelemetry.io/otel/internal/global
 go.opentelemetry.io/otel/propagation
 go.opentelemetry.io/otel/semconv/v1.7.0
-# go.opentelemetry.io/otel/exporters/jaeger v1.3.0
+# go.opentelemetry.io/otel/exporters/jaeger v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/exporters/jaeger
 go.opentelemetry.io/otel/exporters/jaeger/internal/gen-go/agent
 go.opentelemetry.io/otel/exporters/jaeger/internal/gen-go/jaeger
 go.opentelemetry.io/otel/exporters/jaeger/internal/gen-go/zipkincore
 go.opentelemetry.io/otel/exporters/jaeger/internal/third_party/thrift/lib/go/thrift
-# go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.3.0
+# go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/exporters/otlp/internal/retry
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/exporters/otlp/otlptrace
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/otlpconfig
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/internal/tracetransform
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.3.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc
-# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0
+# go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp
-# go.opentelemetry.io/otel/internal/metric v0.26.0
+# go.opentelemetry.io/otel/internal/metric v0.27.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/internal/metric/global
 go.opentelemetry.io/otel/internal/metric/registry
-# go.opentelemetry.io/otel/metric v0.26.0
+# go.opentelemetry.io/otel/metric v0.27.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/metric
 go.opentelemetry.io/otel/metric/global
 go.opentelemetry.io/otel/metric/number
 go.opentelemetry.io/otel/metric/sdkapi
 go.opentelemetry.io/otel/metric/unit
-# go.opentelemetry.io/otel/sdk v1.3.0
+# go.opentelemetry.io/otel/sdk v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/sdk/instrumentation
 go.opentelemetry.io/otel/sdk/internal
+go.opentelemetry.io/otel/sdk/internal/env
 go.opentelemetry.io/otel/sdk/resource
 go.opentelemetry.io/otel/sdk/trace
-# go.opentelemetry.io/otel/trace v1.3.0
+# go.opentelemetry.io/otel/trace v1.4.0
 ## explicit; go 1.16
 go.opentelemetry.io/otel/trace
-# go.opentelemetry.io/proto/otlp v0.11.0
+# go.opentelemetry.io/proto/otlp v0.12.0
 ## explicit; go 1.14
 go.opentelemetry.io/proto/otlp/collector/trace/v1
 go.opentelemetry.io/proto/otlp/common/v1