bump go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/m… (#19477)

bump go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux Signed-off-by: yminer <yminer@vmware.com>
2024-11-26 12:15:20 +01:00 · 2023-10-24 16:21:34 +08:00 · 2023-10-24 16:21:34 +08:00 · adb066cf50
commit adb066cf50
parent 7b0beed934
22 changed files with 1078 additions and 1523 deletions
--- a/src/go.mod
+++ b/src/go.mod
@ -53,7 +53,7 @@ require (
 	github.com/stretchr/testify v1.8.4
 	github.com/tencentcloud/tencentcloud-sdk-go v1.0.62
 	github.com/vmihailenco/msgpack/v5 v5.0.0-rc.2
-	go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.22.0
+	go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.45.0
 	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0
 	go.opentelemetry.io/otel v1.19.0
 	go.opentelemetry.io/otel/exporters/jaeger v1.0.0
@ -153,7 +153,6 @@ require (
 	github.com/subosito/gotenv v1.2.0 // indirect
 	github.com/vmihailenco/tagparser v0.1.2 // indirect
 	go.mongodb.org/mongo-driver v1.7.5 // indirect
 	go.opentelemetry.io/contrib v0.22.0 // indirect
 	go.opentelemetry.io/otel/exporters/otlp/internal/retry v1.3.0 // indirect
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.3.0 // indirect
 	go.opentelemetry.io/otel/metric v1.19.0 // indirect
--- a/src/go.sum
+++ b/src/go.sum
@ -184,7 +184,6 @@ github.com/envoyproxy/go-control-plane v0.9.10-0.20210907150352-cf90f659a021/go.
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
 github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/felixge/httpsnoop v1.0.2/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/felixge/httpsnoop v1.0.3 h1:s/nj+GCswXYzN5v2DpNMuMQYe+0DDwt5WVCU6CWBdXk=
 github.com/felixge/httpsnoop v1.0.3/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/frankban/quicktest v1.14.3 h1:FJKSZTDHjyhriyC81FLQ0LY93eSai0ZyR/ZIkd3ZUKE=
@ -760,15 +759,10 @@ go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
 go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
 go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
-go.opentelemetry.io/contrib v0.22.0 h1:0F7gDEjgb1WGn4ODIjaCAg75hmqF+UN0LiVgwxsCodc=
+go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.45.0 h1:CaagQrotQLgtDlHU6u9pE/Mf4mAwiLD8wrReIVt06lY=
-go.opentelemetry.io/contrib v0.22.0/go.mod h1:EH4yDYeNoaTqn/8yCWQmfNB78VHfGX2Jt2bvnvzBlGM=
+go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.45.0/go.mod h1:LOjFy00/ZMyMYfKFPta6kZe2cDUc1sNo/qtv1pSORWA=
 go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.22.0 h1:Mfz1DMQ43mhQePKqiny6kUTnUrtin+395V67yAIyYhg=
 go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.22.0/go.mod h1:jpoprhHaffWHQ1KBpL0jI+w7979p4ijAL2auucLUj1E=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0 h1:x8Z78aZx8cOF0+Kkazoc7lwUNMGy0LrzEMxTm4BbTxg=
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0/go.mod h1:62CPTSry9QZtOaSsE3tOzhx6LzDhHnXJ6xHeMNNiM6Q=
 go.opentelemetry.io/contrib/propagators v0.22.0 h1:KGdv58M2//veiYLIhb31mofaI2LgkIPXXAZVeYVyfd8=
 go.opentelemetry.io/contrib/propagators v0.22.0/go.mod h1:xGOuXr6lLIF9BXipA4pm6UuOSI0M98U6tsI3khbOiwU=
 go.opentelemetry.io/otel v1.0.0-RC2/go.mod h1:w1thVQ7qbAy8MHb0IFj8a5Q2QU0l2ksf8u/CN8m3NOM=
 go.opentelemetry.io/otel v1.0.0/go.mod h1:AjRVh9A5/5DE7S+mZtTR6t8vpKKryam+0lREnfmS4cg=
 go.opentelemetry.io/otel v1.3.0/go.mod h1:PWIKzi6JCp7sM0k9yZ43VX+T345uNbAkDKwHVjb2PTs=
 go.opentelemetry.io/otel v1.19.0 h1:MuS/TNf4/j4IXsZuJegVzI1cwut7Qc00344rgH7p8bs=
@ -783,13 +777,10 @@ go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0 h1:Ydage/
 go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.3.0/go.mod h1:QNX1aly8ehqqX1LEa6YniTU7VY9I6R3X/oPxhGdTceE=
 go.opentelemetry.io/otel/metric v1.19.0 h1:aTzpGtV0ar9wlV4Sna9sdJyII5jTVJEvKETPiOKwvpE=
 go.opentelemetry.io/otel/metric v1.19.0/go.mod h1:L5rUsV9kM1IxCj1MmSdS+JQAcVm319EUrDVLrt7jqt8=
 go.opentelemetry.io/otel/oteltest v1.0.0-RC2 h1:xNKqMhlZYkASSyvF4JwObZFMq0jhFN3c3SP+2rCzVPk=
 go.opentelemetry.io/otel/oteltest v1.0.0-RC2/go.mod h1:kiQ4tw5tAL4JLTbcOYwK1CWI1HkT5aiLzHovgOVnz/A=
 go.opentelemetry.io/otel/sdk v1.0.0/go.mod h1:PCrDHlSy5x1kjezSdL37PhbFUMjrsLRshJ2zCzeXwbM=
 go.opentelemetry.io/otel/sdk v1.3.0/go.mod h1:rIo4suHNhQwBIPg9axF8V9CA72Wz2mKF1teNrup8yzs=
 go.opentelemetry.io/otel/sdk v1.8.0 h1:xwu69/fNuwbSHWe/0PGS888RmjWY181OmcXDQKu7ZQk=
 go.opentelemetry.io/otel/sdk v1.8.0/go.mod h1:uPSfc+yfDH2StDM/Rm35WE8gXSNdvCg023J6HeGNO0c=
 go.opentelemetry.io/otel/trace v1.0.0-RC2/go.mod h1:JPQ+z6nNw9mqEGT8o3eoPTdnNI+Aj5JcxEsVGREIAy4=
 go.opentelemetry.io/otel/trace v1.0.0/go.mod h1:PXTWqayeFUlJV1YDNhsJYB184+IvAH814St6o6ajzIs=
 go.opentelemetry.io/otel/trace v1.3.0/go.mod h1:c/VDhno8888bvQYmbYLqe41/Ldmr/KKunbvWM4/fEjk=
 go.opentelemetry.io/otel/trace v1.19.0 h1:DFVQmlVbfVeOuBRrwdtaehRrWiL1JoVs9CPIQ1Dzxpg=
--- a/src/vendor/go.opentelemetry.io/contrib/.gitattributes
+++ b/src/vendor/go.opentelemetry.io/contrib/.gitattributes
@ -1,3 +0,0 @@
 * text=auto eol=lf
 *.{cmd,[cC][mM][dD]} text eol=crlf
 *.{bat,[bB][aA][tT]} text eol=crlf
--- a/src/vendor/go.opentelemetry.io/contrib/.gitignore
+++ b/src/vendor/go.opentelemetry.io/contrib/.gitignore
@ -1,13 +0,0 @@
 .DS_Store
 Thumbs.db
 .tools/
 .idea/
 .vscode/
 *.iml
 *.so
 coverage.*
 example
 instrumentation/google.golang.org/grpc/otelgrpc/example/server/server
 instrumentation/google.golang.org/grpc/otelgrpc/example/client/client
--- a/src/vendor/go.opentelemetry.io/contrib/.golangci.yml
+++ b/src/vendor/go.opentelemetry.io/contrib/.golangci.yml
@ -1,32 +0,0 @@
 # See https://github.com/golangci/golangci-lint#config-file
 run:
  issues-exit-code: 1 #Default
  tests: true #Default
 linters:
  enable:
    - misspell
    - goimports
    - revive
    - gofmt
 issues:
  exclude-rules:
    # helpers in tests often (rightfully) pass a *testing.T as their first argument
    - path: _test\.go
      text: "context.Context should be the first parameter of a function"
      linters:
        - revive
    # Yes, they are, but it's okay in a test
    - path: _test\.go
      text: "exported func.*returns unexported type.*which can be annoying to use"
      linters:
        - revive
 linters-settings:
  misspell:
    locale: US
    #ignore-words:
    #  - someword
  goimports:
    local-prefixes: go.opentelemetry.io
--- a/src/vendor/go.opentelemetry.io/contrib/CHANGELOG.md
+++ b/src/vendor/go.opentelemetry.io/contrib/CHANGELOG.md
@ -1,354 +0,0 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 ## [Unreleased]
 ## [0.22.0] - 2021-07-26
 ### Added
 - Add the `zpages` span processor. (#894)
 ### Changed
 - The `b3.B3` type has been removed.
  `b3.New()` and `b3.WithInjectEncoding(encoding)` are added to replace it. (#868)
 ### Fixed
 - Fix deadlocks and race conditions in `otelsarama.WrapAsyncProducer`.
  The `messaging.message_id` and `messaging.kafka.partition` attributes are now not set if a message was not processed. (#754) (#755) (#881)
 - Fix `otelsarama.WrapAsyncProducer` so that the messages from the `Errors` channel contain the original `Metadata`. (#754)
 ## [0.21.0] - 2021-06-18
 ### Fixed
 - Dockerfile based examples for `otelgin` and `otelmacaron`. (#767)
 ### Changed
 - Supported minimum version of Go bumped from 1.14 to 1.15. (#787)
 - EKS Resource Detector now use the Kubernetes Go client to obtain the ConfigMap. (#813)
 ### Removed
 - Remove service name from `otelmongodb` configuration and span attributes. (#763)
 ## [0.20.0] - 2021-04-23
 ### Changed
 - The `go.opentelemetry.io/contrib/instrumentation/go.mongodb.org/mongo-driver/mongo/otelmongo` instrumentation now accepts a `WithCommandAttributeDisabled`, 
   so the caller can specify whether to opt-out of tracing the mongo command. (#712)
 - Upgrade to v0.20.0 of `go.opentelemetry.io/otel`. (#758)
 - The B3 and Jaeger propagators now store their debug or deferred state in the context.Context instead of the SpanContext. (#758)
 ## [0.19.0] - 2021-03-19
 ### Changed
 - Upgrade to v0.19.0 of `go.opentelemetry.io/otel`.
 - Fix Span names created in HTTP Instrumentation package to conform with guidelines. (#757)
 ## [0.18.0] - 2021-03-04
 ### Fixed
 - `otelmemcache` no longer sets span status to OK instead of leaving it unset. (#477)
 - Fix goroutine leak in gRPC `StreamClientInterceptor`. (#581)
 ### Removed
 - Remove service name from `otelmemcache` configuration and span attributes. (#477)
 ## [0.17.0] - 2021-02-15
 ### Added
 - Add `ot-tracer` propagator (#562)
 ### Changed
 - Rename project default branch from `master` to `main`.
 ### Fixed
 - Added failure message for AWS ECS resource detector for better debugging (#568)
 - Goroutine leak in gRPC StreamClientInterceptor while streamer returns an error. (#581)
 ## [0.16.0] - 2021-01-13
 ### Fixed
 - Fix module path for AWS ECS resource detector (#517)
 ## [0.15.1] - 2020-12-14
 ### Added
 - Add registry link check to `Makefile` and pre-release script. (#446)
 - A new AWS X-Ray ID Generator (#459)
 - Migrate CircleCI jobs to GitHub Actions (#476)
 - Add CodeQL GitHub Action (#506)
 - Add gosec workflow to GitHub Actions (#507)
 ### Fixed
 - Fixes the body replacement in otelhttp to not to mutate a nil body. (#484)
 ## [0.15.0] - 2020-12-11
 ### Added
 - A new Amazon EKS resource detector. (#465)
 - A new `gcp.CloudRun` detector for detecting resource from a Cloud Run instance. (#455)
 ## [0.14.0] - 2020-11-20
 ### Added
 - `otelhttp.{Get,Head,Post,PostForm}` convenience wrappers for their `http` counterparts. (#390)
 - The AWS detector now adds the cloud zone, host image ID, host type, and host name to the returned `Resource`. (#410)
 - Add Amazon ECS Resource Detector for AWS X-Ray. (#466)
 - Add propagator for AWS X-Ray (#462)
 ### Changed
 - Add semantic version to `Tracer` / `Meter` created by instrumentation packages `otelsaram`, `otelrestful`, `otelmongo`, `otelhttp` and `otelhttptrace`. (#412)
 - Update instrumentation guidelines about tracer / meter semantic version. (#412)
 - Replace internal tracer and meter helpers by helpers from `go.opentelemetry.io/otel`. (#414)
 - gRPC instrumentation sets span attribute `rpc.grpc.status_code`. (#453)
 ## Fixed
 - `/detectors/aws` no longer fails if instance metadata is not available (e.g. not running in AWS) (#401)
 - The AWS detector now returns a partial resource and an appropriate error if it encounters an error part way through determining a `Resource` identity. (#410)
 - The `host` instrumentation unit test has been updated to not depend on the system it runs on. (#426)
 ## [0.13.0] - 2020-10-09
 ## Added
 - A Jaeger propagator. (#375)
 ## Changed
 - The `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc` package instrumentation no longer accepts a `Tracer` as an argument to the interceptor function.
   Instead, a new `WithTracerProvider` option is added to configure the `TracerProvider` used when creating the `Tracer` for the instrumentation. (#373)
 - The `go.opentelemetry.io/contrib/instrumentation/gopkg.in/macaron.v1/otelmacaron` instrumentation now accepts a `TracerProvider` rather than a `Tracer`. (#374)
 - Remove `go.opentelemetry.io/otel/sdk` dependency from instrumentation. (#381)
 - Use `httpsnoop` in `go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux` to ensure `http.ResponseWriter` additional interfaces are preserved. (#388)
 ### Fixed
 - The `go.opentelemetry.io/contrib/instrumentation/github.com/labstack/echo/otelecho.Middleware` no longer sends duplicate errors to the global `ErrorHandler`. (#377, #364)
 - The import comment in `go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp` is now correctly quoted. (#379)
 - The B3 propagator sets the sample bitmask when the sampling decision is `debug`. (#369)
 ## [0.12.0] - 2020-09-25
 ### Changed
 - Replace `WithTracer` with `WithTracerProvider` in the `go.opentelemetry.io/contrib/instrumentation/gopkg.in/macaron.v1/otelmacaron` instrumentation. (#374)
 ### Added
 - Benchmark tests for the gRPC instrumentation. (#296)
 - Integration testing for the gRPC instrumentation. (#297)
 - Allow custom labels to be added to net/http metrics. (#306)
 - Added B3 propagator, moving it out of open.telemetry.io/otel repo. (#344)
 ### Changed
 - Unify instrumentation about provider options for `go.mongodb.org/mongo-driver`, `gin-gonic/gin`, `gorilla/mux`,
  `labstack/echo`, `emicklei/go-restful`, `bradfitz/gomemcache`, `Shopify/sarama`, `net/http` and `beego`. (#303)
 - Update instrumentation guidelines about uniform provider options. Also, update style guide. (#303)
 - Make config struct of instrumentation unexported. (#303)
 - Instrumentations have been updated to adhere to the [configuration style guide's](https://github.com/open-telemetry/opentelemetry-go/blob/master/CONTRIBUTING.md#config)
   updated recommendation to use `newConfig()` instead of `configure()`. (#336)
 - A new instrumentation naming scheme is implemented to avoid package name conflicts for instrumented packages while still remaining discoverable. (#359)
  - `google.golang.org/grpc` -> `google.golang.org/grpc/otelgrpc`
  - `go.mongodb.org/mongo-driver` -> `go.mongodb.org/mongo-driver/mongo/otelmongo`
  - `net/http` -> `net/http/otelhttp`
  - `net/http/httptrace` -> `net/http/httptrace/otelhttptrace`
  - `github.com/labstack/echo` -> `github.com/labstack/echo/otelecho`
  - `github.com/bradfitz/gomemcache` -> `github.com/bradfitz/gomemcache/memcache/otelmemcache`
  - `github.com/gin-gonic/gin` -> `github.com/gin-gonic/gin/otelgin`
  - `github.com/gocql/gocql` -> `github.com/gocql/gocql/otelgocql`
  - `github.com/emicklei/go-restful` -> `github.com/emicklei/go-restful/otelrestful`
  - `github.com/Shopify/sarama` -> `github.com/Shopify/sarama/otelsarama`
  - `github.com/gorilla/mux` -> `github.com/gorilla/mux/otelmux`
  - `github.com/astaxie/beego` -> `github.com/astaxie/beego/otelbeego`
  - `gopkg.in/macaron.v1` -> `gopkg.in/macaron.v1/otelmacaron`
 - Rename `OTelBeegoHandler` to `Handler` in the `go.opentelemetry.io/contrib/instrumentation/github.com/astaxie/beego/otelbeego` package. (#359)
 ## [0.11.0] - 2020-08-25
 ### Added
 - Top-level `Version()` and `SemVersion()` functions defining the current version of the contrib package. (#225)
 - Instrumentation for the `github.com/astaxie/beego` package. (#200)
 - Instrumentation for the `github.com/bradfitz/gomemcache` package. (#204)
 - Host metrics instrumentation. (#231)
 - Cortex histogram and distribution support. (#237)
 - Cortex example project. (#238)
 - Cortex HTTP authentication. (#246)
 ### Changed
 - Remove service name as a parameter of Sarama instrumentation. (#221)
 - Replace `WithTracer` with `WithTracerProvider` in Sarama instrumentation. (#221)
 - Switch to use common top-level module `SemVersion()` when creating versioned tracer in `bradfitz/gomemcache`. (#226)
 - Use `IntegrationShouldRun` in `gomemcache_test`. (#254)
 - Use Go 1.15 for CI builds. (#236)
 - Improved configuration for `runtime` instrumentation. (#224)
 ### Fixed
 - Update dependabot configuration to include newly added `bradfitz/gomemcache` package. (#226)
 - Correct `runtime` instrumentation name. (#241)
 ## [0.10.1] - 2020-08-13
 ### Added
 - The `go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc` module has been added to replace the instrumentation that had previoiusly existed in the `go.opentelemetry.io/otel/instrumentation/grpctrace` package. (#189)
 - Instrumentation for the stdlib `net/http` and `net/http/httptrace` packages. (#190)
 - Initial Cortex exporter. (#202, #205, #210, #211, #215)
 ### Fixed
 - Bump google.golang.org/grpc from 1.30.0 to 1.31.0. (#166)
 - Bump go.mongodb.org/mongo-driver from 1.3.5 to 1.4.0 in /instrumentation/go.mongodb.org/mongo-driver. (#170)
 - Bump google.golang.org/grpc in /instrumentation/github.com/gin-gonic/gin. (#173)
 - Bump google.golang.org/grpc in /instrumentation/github.com/labstack/echo. (#176)
 - Bump google.golang.org/grpc from 1.30.0 to 1.31.0 in /instrumentation/github.com/Shopify/sarama. (#179)
 - Bump cloud.google.com/go from 0.61.0 to 0.63.0 in /detectors/gcp. (#181, #199)
 - Bump github.com/aws/aws-sdk-go from 1.33.15 to 1.34.1 in /detectors/aws. (#184, #192, #193, #198, #201, #203)
 - Bump github.com/golangci/golangci-lint from 1.29.0 to 1.30.0 in /tools. (#186)
 - Setup CI to run tests that require external resources (Cassandra and MongoDB). (#191)
 - Bump github.com/Shopify/sarama from 1.26.4 to 1.27.0 in /instrumentation/github.com/Shopify/sarama. (#206)
 ## [0.10.0] - 2020-07-31
 This release upgrades its [go.opentelemetry.io/otel](https://github.com/open-telemetry/opentelemetry-go/releases/tag/v0.10.0) dependency to v0.10.0 and includes new instrumentation for popular Kafka and Cassandra clients.
 ### Added
 - A detector that generate resources from GCE instance. (#132)
 - A detector that generate resources from AWS instances. (#139)
 - Instrumentation for the Kafka client github.com/Shopify/sarama. (#134, #153)
 - Links and status message for mock span in the internal testing library. (#134)
 - Instrumentation for the Cassandra client github.com/gocql/gocql. (#137)
 - A detector that generate resources from GKE clusters. (#154)
 ### Fixed
 - Bump github.com/aws/aws-sdk-go from 1.33.8 to 1.33.15 in /detectors/aws. (#155, #157, #159, #162)
 - Bump github.com/golangci/golangci-lint from 1.28.3 to 1.29.0 in /tools. (#146)
 ## [0.9.0] - 2020-07-20
 This release upgrades its [go.opentelemetry.io/otel](https://github.com/open-telemetry/opentelemetry-go/releases/tag/v0.9.0) dependency to v0.9.0.
 ### Fixed
 - Bump github.com/emicklei/go-restful/v3 from 3.0.0 to 3.2.0 in /instrumentation/github.com/emicklei/go-restful. (#133)
 - Update dependabot configuration to correctly check all included packages. (#131)
 - Update `RELEASING.md` with correct `tag.sh` command. (#130)
 ## [0.8.0] - 2020-07-10
 This release upgrades its [go.opentelemetry.io/otel](https://github.com/open-telemetry/opentelemetry-go/releases/tag/v0.8.0) dependency to v0.8.0, includes minor fixes, and new instrumentation.
 ### Added
 - Create this `CHANGELOG.md`. (#114)
 - Add `emicklei/go-restful/v3` trace instrumentation. (#115)
 ### Changed
 - Update `CONTRIBUTING.md` to ask for updates to `CHANGELOG.md` with each pull request. (#114)
 - Move all `github.com` package instrumentation under a `github.com` directory. (#118)
 ### Fixed
 - Update README to include information about external instrumentation.
   To start, this includes native instrumentation found in the `go-redis/redis` package. (#117)
 - Bump github.com/golangci/golangci-lint from 1.27.0 to 1.28.2 in /tools. (#122, #123, #125)
 - Bump go.mongodb.org/mongo-driver from 1.3.4 to 1.3.5 in /instrumentation/go.mongodb.org/mongo-driver. (#124)
 ## [0.7.0] - 2020-06-29
 This release upgrades its [go.opentelemetry.io/otel](https://github.com/open-telemetry/opentelemetry-go/releases/tag/v0.7.0) dependency to v0.7.0.
 ### Added
 - Create `RELEASING.md` instructions. (#101)
 - Apply transitive dependabot go.mod updates as part of a new automatic Github workflow. (#94)
 - New dependabot integration to automate package upgrades. (#61)
 - Add automatic tag generation script for release. (#60)
 ### Changed
 - Upgrade Datadog metrics exporter to include Resource tags. (#46)
 - Added output validation to Datadog example. (#96)
 - Move Macaron package to match layout guidelines. (#92)
 - Update top-level README and instrumentation README. (#92)
 - Bump google.golang.org/grpc from 1.29.1 to 1.30.0. (#99)
 - Bump github.com/golangci/golangci-lint from 1.21.0 to 1.27.0 in /tools. (#77)
 - Bump go.mongodb.org/mongo-driver from 1.3.2 to 1.3.4 in /instrumentation/go.mongodb.org/mongo-driver. (#76)
 - Bump github.com/stretchr/testify from 1.5.1 to 1.6.1. (#74)
 - Bump gopkg.in/macaron.v1 from 1.3.5 to 1.3.9 in /instrumentation/macaron. (#68)
 - Bump github.com/gin-gonic/gin from 1.6.2 to 1.6.3 in /instrumentation/gin-gonic/gin. (#73)
 - Bump github.com/DataDog/datadog-go from 3.5.0+incompatible to 3.7.2+incompatible in /exporters/metric/datadog. (#78)
 - Replaced `internal/trace/http.go` helpers with `api/standard` helpers from otel-go repo. (#112)
 ## [0.6.1] - 2020-06-08
 First official tagged release of `contrib` repository.
 ### Added
 - `labstack/echo` trace instrumentation (#42)
 - `mongodb` trace instrumentation (#26)
 - Go Runtime metrics (#9)
 - `gorilla/mux` trace instrumentation (#19)
 - `gin-gonic` trace instrumentation (#15)
 - `macaron` trace instrumentation (#20)
 - `dogstatsd` metrics exporter (#10)
 - `datadog` metrics exporter (#22)
 - Tags to all modules in repository
 - Repository folder structure and automated build (#3)
 ### Changes
 - Prefix support for dogstatsd (#34)
 - Update Go Runtime package to use batch observer (#44)
 [Unreleased]: https://github.com/open-telemetry/opentelemetry-go-contrib/compare/v0.22.0...HEAD
 [0.22.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.22.0
 [0.21.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.21.0
 [0.20.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.20.0
 [0.19.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.19.0
 [0.18.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.18.0
 [0.17.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.17.0
 [0.16.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.16.0
 [0.15.1]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.15.1
 [0.15.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.15.0
 [0.14.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.14.0
 [0.13.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.13.0
 [0.12.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.12.0
 [0.11.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.11.0
 [0.10.1]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.10.1
 [0.10.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.10.0
 [0.9.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.9.0
 [0.8.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.8.0
 [0.7.0]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.7.0
 [0.6.1]: https://github.com/open-telemetry/opentelemetry-go-contrib/releases/tag/v0.6.1
--- a/src/vendor/go.opentelemetry.io/contrib/CODEOWNERS
+++ b/src/vendor/go.opentelemetry.io/contrib/CODEOWNERS
@ -1,17 +0,0 @@
 #####################################################
 #
 # List of approvers for this repository
 #
 #####################################################
 #
 # Learn about membership in OpenTelemetry community:
 #  https://github.com/open-telemetry/community/blob/main/community-membership.md
 #
 #
 # Learn about CODEOWNERS file format:
 #  https://help.github.com/en/articles/about-code-owners
 #
 * @jmacd @MrAlias @Aneurysm9 @evantorrie @XSAM @dashpole @paivagustavo @MadVikingGod @pellared
 CODEOWNERS @MrAlias @Aneurysm9
--- a/src/vendor/go.opentelemetry.io/contrib/CONTRIBUTING.md
+++ b/src/vendor/go.opentelemetry.io/contrib/CONTRIBUTING.md
@ -1,137 +0,0 @@
 # Contributing to opentelemetry-go-contrib
 The Go special interest group (SIG) meets regularly. See the
 OpenTelemetry
 [community](https://github.com/open-telemetry/community#golang-sdk)
 repo for information on this and other language SIGs.
 See the [public meeting
 notes](https://docs.google.com/document/d/1A63zSWX0x2CyCK_LoNhmQC4rqhLpYXJzXbEPDUQ2n6w/edit#heading=h.9tngw7jdwd6b)
 for a summary description of past meetings. To request edit access,
 join the meeting or get in touch on
 [Slack](https://cloud-native.slack.com/archives/C01NPAXACKT).
 ## Development
 There are some generated files checked into the repo. To make sure
 that the generated files are up-to-date, run `make` (or `make
 precommit` - the `precommit` target is the default).
 The `precommit` target also fixes the formatting of the code and
 checks the status of the go module files.
 If after running `make precommit` the output of `git status` contains
 `nothing to commit, working tree clean` then it means that everything
 is up-to-date and properly formatted.
 ## Pull Requests
 ### How to Send Pull Requests
 Everyone is welcome to contribute code to `opentelemetry-go-contrib` via
 GitHub pull requests (PRs).
 To create a new PR, fork the project in GitHub and clone the upstream
 repo:
 ```sh
 $ git clone https://github.com/open-telemetry/opentelemetry-go-contrib
 ```
 This would put the project in the `opentelemetry-go-contrib` directory in
 current working directory.
 Enter the newly created directory and add your fork as a new remote:
 ```sh
 $ git remote add <YOUR_FORK> git@github.com:<YOUR_GITHUB_USERNAME>/opentelemetry-go
 ```
 Check out a new branch, make modifications, run linters and tests, update
 `CHANGELOG.md` and push the branch to your fork:
 ```sh
 $ git checkout -b <YOUR_BRANCH_NAME>
 # edit files
 # update changelog
 $ make precommit
 $ git add -p
 $ git commit
 $ git push <YOUR_FORK> <YOUR_BRANCH_NAME>
 ```
 Open a pull request against the main `opentelemetry-go-contrib` repo. Be sure to add the pull
 request ID to the entry you added to `CHANGELOG.md`.
 ### How to Receive Comments
 * If the PR is not ready for review, please put `[WIP]` in the title,
  tag it as `work-in-progress`, or mark it as
  [`draft`](https://github.blog/2019-02-14-introducing-draft-pull-requests/).
 * Make sure CLA is signed and CI is clear.
 ### How to Get PRs Merged
 A PR is considered to be **ready to merge** when:
 * It has received two approvals from Approvers/Maintainers (at
  different companies).
 * Feedback has been addressed.
 * Any substantive changes to your PR will require that you clear any prior
  Approval reviews, this includes changes resulting from other feedback. Unless
  the approver explicitly stated that their approval will persist across
  changes it should be assumed that the PR needs their review again. Other
  project members (e.g. approvers, maintainers) can help with this if there are
  any questions or if you forget to clear reviews.
 * It has been open for review for at least one working day. This gives
  people reasonable time to review.
 * Trivial change (typo, cosmetic, doc, etc.) doesn't have to wait for
  one day.
 * `CHANGELOG.md` has been updated to reflect what has been
  added, changed, removed, or fixed.
 * Urgent fix can take exception as long as it has been actively
  communicated.
 Any Maintainer can merge the PR once it is **ready to merge**.
 ## Style Guide
 * Make sure to run `make precommit` - this will find and fix the code
  formatting.
 * Check [opentelemetry-go Style Guide](https://github.com/open-telemetry/opentelemetry-go/blob/main/CONTRIBUTING.md#style-guide)
 ## Adding a new Contrib package
 To add a new contrib package follow an existing one. An empty Sample instrumentation
 provides base structure with an example and a test. Each contrib package 
 should be its own module. A contrib package may contain more than one go package.
 ### Folder Structure
 - instrumentation/\<instrumentation-package>  (**Common**)
 - instrumentation/\<instrumentation-package>/trace (**specific to trace**)
 - instrumentation/\<instrumentation-package>/metrics (**specific to metrics**)
 #### Example
 - instrumentation/gorm/trace
 - instrumentation/kafka/metrics
 ## Approvers and Maintainers
 Approvers:
 - [Evan Torrie](https://github.com/evantorrie), Verizon Media
 - [Josh MacDonald](https://github.com/jmacd), LightStep
 - [Sam Xie](https://github.com/XSAM)
 - [David Ashpole](https://github.com/dashpole), Google
 - [Gustavo Silva Paiva](https://github.com/paivagustavo), LightStep
 - [Aaron Clawson](https://github.com/MadVikingGod)
 - [Robert Pająk](https://github.com/pellared), Splunk
 Maintainers:
 - [Anthony Mirabella](https://github.com/Aneurysm9), Centene
 - [Tyler Yahn](https://github.com/MrAlias), New Relic
 ### Become an Approver or a Maintainer
 See the [community membership document in OpenTelemetry community
 repo](https://github.com/open-telemetry/community/blob/main/community-membership.md).
--- a/src/vendor/go.opentelemetry.io/contrib/LICENSE
+++ b/src/vendor/go.opentelemetry.io/contrib/LICENSE
@ -1,201 +0,0 @@
                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/
   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
   1. Definitions.
      "License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.
      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.
      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.
      "You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.
      "Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.
      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.
      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).
      "Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.
      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."
      "Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.
   2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.
   3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.
   4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:
      (a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and
      (b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and
      (c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and
      (d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.
      You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.
   5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.
   6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.
   7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.
   8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.
   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.
   END OF TERMS AND CONDITIONS
   APPENDIX: How to apply the Apache License to your work.
      To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.
   Copyright [yyyy] [name of copyright owner]
   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.
--- a/src/vendor/go.opentelemetry.io/contrib/Makefile
+++ b/src/vendor/go.opentelemetry.io/contrib/Makefile
@ -1,207 +0,0 @@
 TOOLS_MOD_DIR := ./tools
 # All source code and documents. Used in spell check.
 ALL_DOCS := $(shell find . -name '*.md' -type f | sort)
 # All directories with go.mod files related to opentelemetry library. Used for building, testing and linting.
 ALL_GO_MOD_DIRS := $(filter-out $(TOOLS_MOD_DIR), $(shell find . -type f -name 'go.mod' -exec dirname {} \; | sort))
 ALL_COVERAGE_MOD_DIRS := $(shell find . -type f -name 'go.mod' -exec dirname {} \; | egrep -v '^./example|^$(TOOLS_MOD_DIR)' | sort)
 # URLs to check if all contrib entries exist in the registry.
 REGISTRY_BASE_URL = https://raw.githubusercontent.com/open-telemetry/opentelemetry.io/main/content/en/registry
 CONTRIB_REPO_URL = https://github.com/open-telemetry/opentelemetry-go-contrib/tree/main
 # Mac OS Catalina 10.5.x doesn't support 386. Hence skip 386 test
 SKIP_386_TEST = false
 UNAME_S := $(shell uname -s)
 ifeq ($(UNAME_S),Darwin)
 	SW_VERS := $(shell sw_vers -productVersion)
 	ifeq ($(shell echo $(SW_VERS) | egrep '^(10.1[5-9]|1[1-9]|[2-9])'), $(SW_VERS))
 		SKIP_386_TEST = true
 	endif
 endif
 GO = go
 GOTEST_MIN = go test -v -timeout 30s
 GOTEST = $(GOTEST_MIN) -race
 GOTEST_WITH_COVERAGE = $(GOTEST) -coverprofile=coverage.out -covermode=atomic -coverpkg=./...
 .DEFAULT_GOAL := precommit
 .PHONY: precommit
 TOOLS_DIR := $(abspath ./.tools)
 $(TOOLS_DIR)/golangci-lint: $(TOOLS_MOD_DIR)/go.mod $(TOOLS_MOD_DIR)/go.sum $(TOOLS_MOD_DIR)/tools.go
 	cd $(TOOLS_MOD_DIR) && \
 	go build -o $(TOOLS_DIR)/golangci-lint github.com/golangci/golangci-lint/cmd/golangci-lint
 $(TOOLS_DIR)/misspell: $(TOOLS_MOD_DIR)/go.mod $(TOOLS_MOD_DIR)/go.sum $(TOOLS_MOD_DIR)/tools.go
 	cd $(TOOLS_MOD_DIR) && \
 	go build -o $(TOOLS_DIR)/misspell github.com/client9/misspell/cmd/misspell
 $(TOOLS_DIR)/stringer: $(TOOLS_MOD_DIR)/go.mod $(TOOLS_MOD_DIR)/go.sum $(TOOLS_MOD_DIR)/tools.go
 	cd $(TOOLS_MOD_DIR) && \
 	go build -o $(TOOLS_DIR)/stringer golang.org/x/tools/cmd/stringer
 precommit: dependabot-check license-check generate lint build test
 .PHONY: test-with-coverage
 test-with-coverage:
 	set -e; \
 	printf "" > coverage.txt; \
 	for dir in $(ALL_COVERAGE_MOD_DIRS); do \
 	  echo "go test ./... + coverage in $${dir}"; \
 	  (cd "$${dir}" && \
 	    $(GOTEST_WITH_COVERAGE) ./... && \
 	    go tool cover -html=coverage.out -o coverage.html); \
 	  [ -f "$${dir}/coverage.out" ] && cat "$${dir}/coverage.out" >> coverage.txt; \
 	done; \
 	sed -i.bak -e '2,$$ { /^mode: /d; }' coverage.txt && rm coverage.txt.bak
 .PHONY: ci
 ci: precommit check-clean-work-tree test-with-coverage test-386
 .PHONY: test-gocql
 test-gocql:
 	@if ./tools/should_build.sh gocql; then \
 	  set -e; \
 	  docker run --name cass-integ --rm -p 9042:9042 -d cassandra:3; \
 	  CMD=cassandra IMG_NAME=cass-integ ./tools/wait.sh; \
 	  (cd instrumentation/github.com/gocql/gocql/otelgocql && \
 	    $(GOTEST_WITH_COVERAGE) . && \
 	    go tool cover -html=coverage.out -o coverage.html); \
 	  docker stop cass-integ; \
 	fi
 .PHONY: test-mongo-driver
 test-mongo-driver:
 	@if ./tools/should_build.sh mongo-driver; then \
 	  set -e; \
 	  docker run --name mongo-integ --rm -p 27017:27017 -d mongo; \
 	  CMD=mongo IMG_NAME=mongo-integ ./tools/wait.sh; \
 	  (cd instrumentation/go.mongodb.org/mongo-driver/mongo/otelmongo && \
 	    $(GOTEST_WITH_COVERAGE) . && \
 	    go tool cover -html=coverage.out -o coverage.html); \
 	  docker stop mongo-integ; \
 	fi
 .PHONY: test-gomemcache
 test-gomemcache:
 	@if ./tools/should_build.sh gomemcache; then \
 	  set -e; \
 	  docker run --name gomemcache-integ --rm -p 11211:11211 -d memcached; \
 	  CMD=gomemcache IMG_NAME=gomemcache-integ  ./tools/wait.sh; \
 	  (cd instrumentation/github.com/bradfitz/gomemcache/memcache/otelmemcache && \
 	    $(GOTEST_WITH_COVERAGE) . && \
 	    go tool cover -html=coverage.out -o coverage.html); \
 	  docker stop gomemcache-integ ; \
 	fi
 .PHONY: check-clean-work-tree
 check-clean-work-tree:
 	@if ! git diff --quiet; then \
 	  echo; \
 	  echo 'Working tree is not clean, did you forget to run "make precommit"?'; \
 	  echo; \
 	  git status; \
 	  exit 1; \
 	fi
 .PHONY: build
 build:
 	# TODO: Fix this on windows.
 	set -e; for dir in $(ALL_GO_MOD_DIRS); do \
 	  echo "compiling all packages in $${dir}"; \
 	  (cd "$${dir}" && \
 	    go build ./... && \
 	    go test -run xxxxxMatchNothingxxxxx ./... >/dev/null); \
 	done
 .PHONY: test
 test:
 	set -e; for dir in $(ALL_GO_MOD_DIRS); do \
 	  echo "go test ./... + race in $${dir}"; \
 	  (cd "$${dir}" && \
 	    $(GOTEST) ./...); \
 	done
 .PHONY: test-386
 test-386:
 	if [ $(SKIP_386_TEST) = true ] ; then \
 		echo "skipping the test for GOARCH 386 as it is not supported on the current OS"; \
  else \
    set -e; for dir in $(ALL_GO_MOD_DIRS); do \
        echo "go test ./... GOARCH 386 in $${dir}"; \
        (cd "$${dir}" && \
          GOARCH=386 $(GOTEST_MIN) ./...); \
 	  done; \
 	fi
 .PHONY: lint
 lint: $(TOOLS_DIR)/golangci-lint $(TOOLS_DIR)/misspell lint-modules
 	set -e; for dir in $(ALL_GO_MOD_DIRS); do \
 	  echo "golangci-lint in $${dir}"; \
 	  (cd "$${dir}" && \
 	    $(TOOLS_DIR)/golangci-lint run --fix && \
 	    $(TOOLS_DIR)/golangci-lint run); \
 	done
 	$(TOOLS_DIR)/misspell -w $(ALL_DOCS)
 .PHONY: lint-modules
 lint-modules:
 	set -e; for dir in $(ALL_GO_MOD_DIRS) $(TOOLS_MOD_DIR); do \
 	  echo "$(GO) mod tidy in $${dir}"; \
 	  (cd "$${dir}" && \
 	    $(GO) mod tidy); \
 	done
 .PHONY: generate
 generate: $(TOOLS_DIR)/stringer
 	PATH="$(TOOLS_DIR):$${PATH}" go generate ./...
 .PHONY: license-check
 license-check:
 	@licRes=$$(for f in $$(find . -type f \( -iname '*.go' -o -iname '*.sh' \) ! -path './vendor/*' ! -path './exporters/otlp/internal/opentelemetry-proto/*') ; do \
 	           awk '/Copyright The OpenTelemetry Authors|generated|GENERATED/ && NR<=3 { found=1; next } END { if (!found) print FILENAME }' $$f; \
 	   done); \
 	   if [ -n "$${licRes}" ]; then \
 	           echo "license header checking failed:"; echo "$${licRes}"; \
 	           exit 1; \
 	   fi
 .PHONY: registry-links-check
 registry-links-check:
 	@checkRes=$$( \
 		for f in $$( find ./instrumentation ./exporters ./detectors ! -path './instrumentation/net/*' -type f -name 'go.mod' -exec dirname {} \; | egrep -v '/example|/utils' | sort ) \
 			./instrumentation/net/http; do \
 			TYPE="instrumentation"; \
 			if $$(echo "$$f" | grep -q "exporters"); then \
 				TYPE="exporter"; \
 			fi; \
 			if $$(echo "$$f" | grep -q "detectors"); then \
 				TYPE="detector"; \
 			fi; \
 			NAME=$$(echo "$$f" | sed -e 's/.*\///' -e 's/.*otel//'); \
 			LINK=$(CONTRIB_REPO_URL)/$$(echo "$$f" | sed -e 's/..//' -e 's/\/otel.*$$//'); \
 			if ! $$(curl -s $(REGISTRY_BASE_URL)/$${TYPE}-go-$${NAME}.md | grep -q "$${LINK}"); then \
 				echo "$$f"; \
 			fi \
 		done; \
 	); \
 	if [ -n "$$checkRes" ]; then \
 		echo "WARNING: registry link check failed for the following packages:"; echo "$${checkRes}"; \
 	fi
 .PHONY: dependabot-check
 dependabot-check:
 	@result=$$( \
 		for f in $$( find . -type f -name go.mod -exec dirname {} \; | sed 's/^.\/\?/\//' ); \
 			do grep -q "$$f" .github/dependabot.yml \
 			|| echo "$$f"; \
 		done; \
 	); \
 	if [ -n "$$result" ]; then \
 		echo "missing go.mod dependabot check:"; echo "$$result"; \
 		exit 1; \
 	fi
--- a/src/vendor/go.opentelemetry.io/contrib/README.md
+++ b/src/vendor/go.opentelemetry.io/contrib/README.md
@ -1,40 +0,0 @@
 # OpenTelemetry-Go Contrib
 [![build_and_test](https://github.com/open-telemetry/opentelemetry-go-contrib/workflows/build_and_test/badge.svg)](https://github.com/open-telemetry/opentelemetry-go-contrib/actions?query=workflow%3Abuild_and_test+branch%3Amain)
 [![codecov.io](https://codecov.io/gh/open-telemetry/opentelemetry-go-contrib/coverage.svg?branch=main)](https://app.codecov.io/gh/open-telemetry/opentelemetry-go-contrib?branch=main)
 [![Docs](https://godoc.org/go.opentelemetry.io/contrib?status.svg)](https://pkg.go.dev/go.opentelemetry.io/contrib)
 [![Go Report Card](https://goreportcard.com/badge/go.opentelemetry.io/contrib)](https://goreportcard.com/report/go.opentelemetry.io/contrib)
 [![Slack](https://img.shields.io/badge/slack-@cncf/otel--go-brightgreen.svg?logo=slack)](https://cloud-native.slack.com/archives/C01NPAXACKT)
 Collection of 3rd-party instrumentation and exporters for [OpenTelemetry-Go](https://github.com/open-telemetry/opentelemetry-go).
 ## Contents
 - [Instrumentation](./instrumentation/): Packages providing OpenTelemetry instrumentation for 3rd-party libraries.
 - [Exporters](./exporters/): Packages providing OpenTelemetry exporters for 3rd-party telemetry systems.
 - [Propagators](./propagators/): Packages providing OpenTelemetry context propagators for 3rd-party propagation formats.
 - [Detectors](./detectors/): Packages providing OpenTelemetry resource detectors for 3rd-party cloud computing environments.
 ## Project Status
 This project is currently in a pre-GA phase. Our progress towards a GA release
 candidate is tracked in [this project
 board](https://github.com/orgs/open-telemetry/projects/5).
 ### Compatibility
 This project is tested on the following systems.
 | OS      | Go Version | Architecture |
 | ------- | ---------- | ------------ |
 | Ubuntu  | 1.16       | amd64        |
 | Ubuntu  | 1.15       | amd64        |
 | Ubuntu  | 1.16       | 386          |
 | Ubuntu  | 1.15       | 386          |
 While this project should work for other systems, no compatibility guarantees
 are made for those systems currently.
 ## Contributing
 For information on how to contribute, consult [the contributing guidelines](./CONTRIBUTING.md)
--- a/src/vendor/go.opentelemetry.io/contrib/RELEASING.md
+++ b/src/vendor/go.opentelemetry.io/contrib/RELEASING.md
@ -1,96 +0,0 @@
 # Release Process
 There are two types of release for the `go.opentelemetry.io/contrib` repo
 and submodules.
 1. **Case 1** A release due to changes independent of the
 `go.opentelemetry.io/otel` module, e.g. perhaps a critical bug fix in
 one of the contrib modules.
 2. **Case 2** A release due to a breaking API change in
 `go.opentelemetry.io/otel` which all modules in this repo
 depend on.
 ## Pre-Release
 Update go.mod for submodules to depend on the upcoming new release of
 the module in this repo, `go.opentelemetry.io/contrib`.  Decide on the
 next version of the semantic tag to apply to the contrib
 module based on whether you fall into Case 1 or Case 2.
 ### Case 1
 If the changes are all internal to this repo, then the new tag will
 most often be a patch or minor version upgrade to the existing tag on
 this module. Let's call this `<new_contrib_tag>`.
 ### Case 2
 If a new release is required due to breaking changes in
 `go.opentelemetry.io/otel`, then the new semantic tag for this repo
 should be bumped to match the `go.opentelemetry.io/otel` new tag.
 Let's call this `<new_otel_tag>`. The script checks that
 `go.opentelemetry.io/otel@v<new_otel_tag>` is a valid tag, so you need
 to wait until that tag has been pushed in the main repo.
 In nearly all cases, `<new_contrib_tag>` should be the same as
 `<new_otel_tag>`.
 1. Run `pre_release.sh` script to create a branch `pre_release_<new_contrib_tag>`.
   The script will also run `go mod tidy` and `make ci`.
   * **Case 1** `./pre_release.sh -t <new_contrib_tag>`
   * **Case 2** `./pre_release.sh -o <new_otel_tag> [-t <new_contrib_tag>]`
 2. If you used `-o <new_otel_tag>` to rewrite the modules to depend on
   a new version of `go.opentelemetry.io/otel`, there will likely be
   breaking changes that require fixes to the files in this
   `contrib` repo.  Make the appropriate fixes to address any API
   breaks and run through the
        ```
        git commit -m "fixes due to API changes"
        make precommit
        ```
   cycle until everything passes
 4. Push the changes to upstream.
    ```
    git diff main
    git push
    ```
 5. Create a PR on github and merge the PR once approved.
 ### Tag
 Now create a `<new_contrib_tag>` on the commit hash of the changes made in pre-release step,
 1. Run the tag.sh script.
    ```
    ./tag.sh <new_contrib_tag> <commit-hash>
    ```
 2. Push tags upstream. Make sure you push upstream for all the sub-module tags as well.
    ```
    git push upstream <new_contrib_tag>
    git push upstream <submodules-path/new_contrib_tag>
    ...
    ```
 ## Release
 Now create a release for the new `<new_contrib_tag>` on github.
 The release body should include all the release notes in the Changelog for this release.
 Additionally, the `tag.sh` script generates commit logs since last release which can be used to suppliment the release notes.
 <!-- ## Verify Examples -->
 <!-- After releasing run following script to verify that examples build outside of the otel repo. -->
 <!-- The script copies examples into a different directory and builds them. -->
 <!-- ``` -->
 <!-- ./verify_examples.sh -->
 <!-- ``` -->
--- a/src/vendor/go.opentelemetry.io/contrib/doc.go
+++ b/src/vendor/go.opentelemetry.io/contrib/doc.go
@ -1,20 +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.
 // This package provides all of its functionality through its
 // submodules. The submodules in the exporters directory provide
 // implementations for trace and metric exporters for third-party
 // collectors, and submodules in the instrumentation directory provide the
 // instrumentation for the popular go libraries.
 package contrib
--- a/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/config.go
+++ b/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/config.go
@ -12,9 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
-package otelmux
+package otelmux // import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
 import (
 	"net/http"
 	"go.opentelemetry.io/otel/propagation"
 	oteltrace "go.opentelemetry.io/otel/trace"
 )
@ -23,6 +25,10 @@ import (
 type config struct {
 	TracerProvider    oteltrace.TracerProvider
 	Propagators       propagation.TextMapPropagator
 	spanNameFormatter func(string, *http.Request) string
 	PublicEndpoint    bool
 	PublicEndpointFn  func(*http.Request) bool
 	Filters           []Filter
 }
 // Option specifies instrumentation configuration options.
@ -36,12 +42,38 @@ func (o optionFunc) apply(c *config) {
 	o(c)
 }
 // Filter is a predicate used to determine whether a given http.request should
 // be traced. A Filter must return true if the request should be traced.
 type Filter func(*http.Request) bool
 // WithPublicEndpoint configures the Handler to link the span with an incoming
 // span context. If this option is not provided, then the association is a child
 // association instead of a link.
 func WithPublicEndpoint() Option {
 	return optionFunc(func(c *config) {
 		c.PublicEndpoint = true
 	})
 }
 // WithPublicEndpointFn runs with every request, and allows conditionnally
 // configuring the Handler to link the span with an incoming span context. If
 // this option is not provided or returns false, then the association is a
 // child association instead of a link.
 // Note: WithPublicEndpoint takes precedence over WithPublicEndpointFn.
 func WithPublicEndpointFn(fn func(*http.Request) bool) Option {
 	return optionFunc(func(c *config) {
 		c.PublicEndpointFn = fn
 	})
 }
 // WithPropagators specifies propagators to use for extracting
 // information from the HTTP requests. If none are specified, global
 // ones will be used.
 func WithPropagators(propagators propagation.TextMapPropagator) Option {
 	return optionFunc(func(cfg *config) {
 		if propagators != nil {
 			cfg.Propagators = propagators
 		}
 	})
 }
@ -49,6 +81,30 @@ func WithPropagators(propagators propagation.TextMapPropagator) Option {
 // If none is specified, the global provider is used.
 func WithTracerProvider(provider oteltrace.TracerProvider) Option {
 	return optionFunc(func(cfg *config) {
 		if provider != nil {
 			cfg.TracerProvider = provider
 		}
 	})
 }
 // WithSpanNameFormatter specifies a function to use for generating a custom span
 // name. By default, the route name (path template or regexp) is used. The route
 // name is provided so you can use it in the span name without needing to
 // duplicate the logic for extracting it from the request.
 func WithSpanNameFormatter(fn func(routeName string, r *http.Request) string) Option {
 	return optionFunc(func(cfg *config) {
 		cfg.spanNameFormatter = fn
 	})
 }
 // WithFilter adds a filter to the list of filters used by the handler.
 // If any filter indicates to exclude a request then the request will not be
 // traced. All filters must allow a request to be traced for a Span to be created.
 // If no filters are provided then all requests are traced.
 // Filters will be invoked for each processed request, it is advised to make them
 // simple and fast.
 func WithFilter(f Filter) Option {
 	return optionFunc(func(c *config) {
 		c.Filters = append(c.Filters, f)
 	})
 }
--- a/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil/gen.go
+++ b/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil/gen.go
@ -0,0 +1,21 @@
 // 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 semconvutil // import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil"
 // Generate semconvutil package:
 //go:generate gotmpl --body=../../../../../../../internal/shared/semconvutil/httpconv_test.go.tmpl "--data={}" --out=httpconv_test.go
 //go:generate gotmpl --body=../../../../../../../internal/shared/semconvutil/httpconv.go.tmpl "--data={}" --out=httpconv.go
 //go:generate gotmpl --body=../../../../../../../internal/shared/semconvutil/netconv_test.go.tmpl "--data={}" --out=netconv_test.go
 //go:generate gotmpl --body=../../../../../../../internal/shared/semconvutil/netconv.go.tmpl "--data={}" --out=netconv.go
--- a/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil/httpconv.go
+++ b/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil/httpconv.go
@ -0,0 +1,552 @@
 // Code created by gotmpl. DO NOT MODIFY.
 // source: internal/shared/semconvutil/httpconv.go.tmpl
 // 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 semconvutil // import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil"
 import (
 	"fmt"
 	"net/http"
 	"strings"
 	"go.opentelemetry.io/otel/attribute"
 	"go.opentelemetry.io/otel/codes"
 	semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
 )
 // HTTPClientResponse returns trace attributes for an HTTP response received by a
 // client from a server. It will return the following attributes if the related
 // values are defined in resp: "http.status.code",
 // "http.response_content_length".
 //
 // This does not add all OpenTelemetry required attributes for an HTTP event,
 // it assumes ClientRequest was used to create the span with a complete set of
 // attributes. If a complete set of attributes can be generated using the
 // request contained in resp. For example:
 //
 //	append(HTTPClientResponse(resp), ClientRequest(resp.Request)...)
 func HTTPClientResponse(resp *http.Response) []attribute.KeyValue {
 	return hc.ClientResponse(resp)
 }
 // HTTPClientRequest returns trace attributes for an HTTP request made by a client.
 // The following attributes are always returned: "http.url", "http.flavor",
 // "http.method", "net.peer.name". The following attributes are returned if the
 // related values are defined in req: "net.peer.port", "http.user_agent",
 // "http.request_content_length", "enduser.id".
 func HTTPClientRequest(req *http.Request) []attribute.KeyValue {
 	return hc.ClientRequest(req)
 }
 // HTTPClientStatus returns a span status code and message for an HTTP status code
 // value received by a client.
 func HTTPClientStatus(code int) (codes.Code, string) {
 	return hc.ClientStatus(code)
 }
 // HTTPServerRequest returns trace attributes for an HTTP request received by a
 // server.
 //
 // The server must be the primary server name if it is known. For example this
 // would be the ServerName directive
 // (https://httpd.apache.org/docs/2.4/mod/core.html#servername) for an Apache
 // server, and the server_name directive
 // (http://nginx.org/en/docs/http/ngx_http_core_module.html#server_name) for an
 // nginx server. More generically, the primary server name would be the host
 // header value that matches the default virtual host of an HTTP server. It
 // should include the host identifier and if a port is used to route to the
 // server that port identifier should be included as an appropriate port
 // suffix.
 //
 // If the primary server name is not known, server should be an empty string.
 // The req Host will be used to determine the server instead.
 //
 // The following attributes are always returned: "http.method", "http.scheme",
 // "http.flavor", "http.target", "net.host.name". The following attributes are
 // returned if they related values are defined in req: "net.host.port",
 // "net.sock.peer.addr", "net.sock.peer.port", "http.user_agent", "enduser.id",
 // "http.client_ip".
 func HTTPServerRequest(server string, req *http.Request) []attribute.KeyValue {
 	return hc.ServerRequest(server, req)
 }
 // HTTPServerRequestMetrics returns metric attributes for an HTTP request received by a
 // server.
 //
 // The server must be the primary server name if it is known. For example this
 // would be the ServerName directive
 // (https://httpd.apache.org/docs/2.4/mod/core.html#servername) for an Apache
 // server, and the server_name directive
 // (http://nginx.org/en/docs/http/ngx_http_core_module.html#server_name) for an
 // nginx server. More generically, the primary server name would be the host
 // header value that matches the default virtual host of an HTTP server. It
 // should include the host identifier and if a port is used to route to the
 // server that port identifier should be included as an appropriate port
 // suffix.
 //
 // If the primary server name is not known, server should be an empty string.
 // The req Host will be used to determine the server instead.
 //
 // The following attributes are always returned: "http.method", "http.scheme",
 // "http.flavor", "net.host.name". The following attributes are
 // returned if they related values are defined in req: "net.host.port".
 func HTTPServerRequestMetrics(server string, req *http.Request) []attribute.KeyValue {
 	return hc.ServerRequestMetrics(server, req)
 }
 // HTTPServerStatus returns a span status code and message for an HTTP status code
 // value returned by a server. Status codes in the 400-499 range are not
 // returned as errors.
 func HTTPServerStatus(code int) (codes.Code, string) {
 	return hc.ServerStatus(code)
 }
 // HTTPRequestHeader returns the contents of h as attributes.
 //
 // Instrumentation should require an explicit configuration of which headers to
 // captured and then prune what they pass here. Including all headers can be a
 // security risk - explicit configuration helps avoid leaking sensitive
 // information.
 //
 // The User-Agent header is already captured in the http.user_agent attribute
 // from ClientRequest and ServerRequest. Instrumentation may provide an option
 // to capture that header here even though it is not recommended. Otherwise,
 // instrumentation should filter that out of what is passed.
 func HTTPRequestHeader(h http.Header) []attribute.KeyValue {
 	return hc.RequestHeader(h)
 }
 // HTTPResponseHeader returns the contents of h as attributes.
 //
 // Instrumentation should require an explicit configuration of which headers to
 // captured and then prune what they pass here. Including all headers can be a
 // security risk - explicit configuration helps avoid leaking sensitive
 // information.
 //
 // The User-Agent header is already captured in the http.user_agent attribute
 // from ClientRequest and ServerRequest. Instrumentation may provide an option
 // to capture that header here even though it is not recommended. Otherwise,
 // instrumentation should filter that out of what is passed.
 func HTTPResponseHeader(h http.Header) []attribute.KeyValue {
 	return hc.ResponseHeader(h)
 }
 // httpConv are the HTTP semantic convention attributes defined for a version
 // of the OpenTelemetry specification.
 type httpConv struct {
 	NetConv *netConv
 	EnduserIDKey                 attribute.Key
 	HTTPClientIPKey              attribute.Key
 	HTTPFlavorKey                attribute.Key
 	HTTPMethodKey                attribute.Key
 	HTTPRequestContentLengthKey  attribute.Key
 	HTTPResponseContentLengthKey attribute.Key
 	HTTPRouteKey                 attribute.Key
 	HTTPSchemeHTTP               attribute.KeyValue
 	HTTPSchemeHTTPS              attribute.KeyValue
 	HTTPStatusCodeKey            attribute.Key
 	HTTPTargetKey                attribute.Key
 	HTTPURLKey                   attribute.Key
 	HTTPUserAgentKey             attribute.Key
 }
 var hc = &httpConv{
 	NetConv: nc,
 	EnduserIDKey:                 semconv.EnduserIDKey,
 	HTTPClientIPKey:              semconv.HTTPClientIPKey,
 	HTTPFlavorKey:                semconv.HTTPFlavorKey,
 	HTTPMethodKey:                semconv.HTTPMethodKey,
 	HTTPRequestContentLengthKey:  semconv.HTTPRequestContentLengthKey,
 	HTTPResponseContentLengthKey: semconv.HTTPResponseContentLengthKey,
 	HTTPRouteKey:                 semconv.HTTPRouteKey,
 	HTTPSchemeHTTP:               semconv.HTTPSchemeHTTP,
 	HTTPSchemeHTTPS:              semconv.HTTPSchemeHTTPS,
 	HTTPStatusCodeKey:            semconv.HTTPStatusCodeKey,
 	HTTPTargetKey:                semconv.HTTPTargetKey,
 	HTTPURLKey:                   semconv.HTTPURLKey,
 	HTTPUserAgentKey:             semconv.HTTPUserAgentKey,
 }
 // ClientResponse returns attributes for an HTTP response received by a client
 // from a server. The following attributes are returned if the related values
 // are defined in resp: "http.status.code", "http.response_content_length".
 //
 // This does not add all OpenTelemetry required attributes for an HTTP event,
 // it assumes ClientRequest was used to create the span with a complete set of
 // attributes. If a complete set of attributes can be generated using the
 // request contained in resp. For example:
 //
 //	append(ClientResponse(resp), ClientRequest(resp.Request)...)
 func (c *httpConv) ClientResponse(resp *http.Response) []attribute.KeyValue {
 	var n int
 	if resp.StatusCode > 0 {
 		n++
 	}
 	if resp.ContentLength > 0 {
 		n++
 	}
 	attrs := make([]attribute.KeyValue, 0, n)
 	if resp.StatusCode > 0 {
 		attrs = append(attrs, c.HTTPStatusCodeKey.Int(resp.StatusCode))
 	}
 	if resp.ContentLength > 0 {
 		attrs = append(attrs, c.HTTPResponseContentLengthKey.Int(int(resp.ContentLength)))
 	}
 	return attrs
 }
 // ClientRequest returns attributes for an HTTP request made by a client. The
 // following attributes are always returned: "http.url", "http.flavor",
 // "http.method", "net.peer.name". The following attributes are returned if the
 // related values are defined in req: "net.peer.port", "http.user_agent",
 // "http.request_content_length", "enduser.id".
 func (c *httpConv) ClientRequest(req *http.Request) []attribute.KeyValue {
 	n := 3 // URL, peer name, proto, and method.
 	var h string
 	if req.URL != nil {
 		h = req.URL.Host
 	}
 	peer, p := firstHostPort(h, req.Header.Get("Host"))
 	port := requiredHTTPPort(req.URL != nil && req.URL.Scheme == "https", p)
 	if port > 0 {
 		n++
 	}
 	useragent := req.UserAgent()
 	if useragent != "" {
 		n++
 	}
 	if req.ContentLength > 0 {
 		n++
 	}
 	userID, _, hasUserID := req.BasicAuth()
 	if hasUserID {
 		n++
 	}
 	attrs := make([]attribute.KeyValue, 0, n)
 	attrs = append(attrs, c.method(req.Method))
 	attrs = append(attrs, c.flavor(req.Proto))
 	var u string
 	if req.URL != nil {
 		// Remove any username/password info that may be in the URL.
 		userinfo := req.URL.User
 		req.URL.User = nil
 		u = req.URL.String()
 		// Restore any username/password info that was removed.
 		req.URL.User = userinfo
 	}
 	attrs = append(attrs, c.HTTPURLKey.String(u))
 	attrs = append(attrs, c.NetConv.PeerName(peer))
 	if port > 0 {
 		attrs = append(attrs, c.NetConv.PeerPort(port))
 	}
 	if useragent != "" {
 		attrs = append(attrs, c.HTTPUserAgentKey.String(useragent))
 	}
 	if l := req.ContentLength; l > 0 {
 		attrs = append(attrs, c.HTTPRequestContentLengthKey.Int64(l))
 	}
 	if hasUserID {
 		attrs = append(attrs, c.EnduserIDKey.String(userID))
 	}
 	return attrs
 }
 // ServerRequest returns attributes for an HTTP request received by a server.
 //
 // The server must be the primary server name if it is known. For example this
 // would be the ServerName directive
 // (https://httpd.apache.org/docs/2.4/mod/core.html#servername) for an Apache
 // server, and the server_name directive
 // (http://nginx.org/en/docs/http/ngx_http_core_module.html#server_name) for an
 // nginx server. More generically, the primary server name would be the host
 // header value that matches the default virtual host of an HTTP server. It
 // should include the host identifier and if a port is used to route to the
 // server that port identifier should be included as an appropriate port
 // suffix.
 //
 // If the primary server name is not known, server should be an empty string.
 // The req Host will be used to determine the server instead.
 //
 // The following attributes are always returned: "http.method", "http.scheme",
 // "http.flavor", "http.target", "net.host.name". The following attributes are
 // returned if they related values are defined in req: "net.host.port",
 // "net.sock.peer.addr", "net.sock.peer.port", "http.user_agent", "enduser.id",
 // "http.client_ip".
 func (c *httpConv) ServerRequest(server string, req *http.Request) []attribute.KeyValue {
 	// TODO: This currently does not add the specification required
 	// `http.target` attribute. It has too high of a cardinality to safely be
 	// added. An alternate should be added, or this comment removed, when it is
 	// addressed by the specification. If it is ultimately decided to continue
 	// not including the attribute, the HTTPTargetKey field of the httpConv
 	// should be removed as well.
 	n := 4 // Method, scheme, proto, and host name.
 	var host string
 	var p int
 	if server == "" {
 		host, p = splitHostPort(req.Host)
 	} else {
 		// Prioritize the primary server name.
 		host, p = splitHostPort(server)
 		if p < 0 {
 			_, p = splitHostPort(req.Host)
 		}
 	}
 	hostPort := requiredHTTPPort(req.TLS != nil, p)
 	if hostPort > 0 {
 		n++
 	}
 	peer, peerPort := splitHostPort(req.RemoteAddr)
 	if peer != "" {
 		n++
 		if peerPort > 0 {
 			n++
 		}
 	}
 	useragent := req.UserAgent()
 	if useragent != "" {
 		n++
 	}
 	userID, _, hasUserID := req.BasicAuth()
 	if hasUserID {
 		n++
 	}
 	clientIP := serverClientIP(req.Header.Get("X-Forwarded-For"))
 	if clientIP != "" {
 		n++
 	}
 	attrs := make([]attribute.KeyValue, 0, n)
 	attrs = append(attrs, c.method(req.Method))
 	attrs = append(attrs, c.scheme(req.TLS != nil))
 	attrs = append(attrs, c.flavor(req.Proto))
 	attrs = append(attrs, c.NetConv.HostName(host))
 	if hostPort > 0 {
 		attrs = append(attrs, c.NetConv.HostPort(hostPort))
 	}
 	if peer != "" {
 		// The Go HTTP server sets RemoteAddr to "IP:port", this will not be a
 		// file-path that would be interpreted with a sock family.
 		attrs = append(attrs, c.NetConv.SockPeerAddr(peer))
 		if peerPort > 0 {
 			attrs = append(attrs, c.NetConv.SockPeerPort(peerPort))
 		}
 	}
 	if useragent != "" {
 		attrs = append(attrs, c.HTTPUserAgentKey.String(useragent))
 	}
 	if hasUserID {
 		attrs = append(attrs, c.EnduserIDKey.String(userID))
 	}
 	if clientIP != "" {
 		attrs = append(attrs, c.HTTPClientIPKey.String(clientIP))
 	}
 	return attrs
 }
 // ServerRequestMetrics returns metric attributes for an HTTP request received
 // by a server.
 //
 // The server must be the primary server name if it is known. For example this
 // would be the ServerName directive
 // (https://httpd.apache.org/docs/2.4/mod/core.html#servername) for an Apache
 // server, and the server_name directive
 // (http://nginx.org/en/docs/http/ngx_http_core_module.html#server_name) for an
 // nginx server. More generically, the primary server name would be the host
 // header value that matches the default virtual host of an HTTP server. It
 // should include the host identifier and if a port is used to route to the
 // server that port identifier should be included as an appropriate port
 // suffix.
 //
 // If the primary server name is not known, server should be an empty string.
 // The req Host will be used to determine the server instead.
 //
 // The following attributes are always returned: "http.method", "http.scheme",
 // "http.flavor", "net.host.name". The following attributes are
 // returned if they related values are defined in req: "net.host.port".
 func (c *httpConv) ServerRequestMetrics(server string, req *http.Request) []attribute.KeyValue {
 	// TODO: This currently does not add the specification required
 	// `http.target` attribute. It has too high of a cardinality to safely be
 	// added. An alternate should be added, or this comment removed, when it is
 	// addressed by the specification. If it is ultimately decided to continue
 	// not including the attribute, the HTTPTargetKey field of the httpConv
 	// should be removed as well.
 	n := 4 // Method, scheme, proto, and host name.
 	var host string
 	var p int
 	if server == "" {
 		host, p = splitHostPort(req.Host)
 	} else {
 		// Prioritize the primary server name.
 		host, p = splitHostPort(server)
 		if p < 0 {
 			_, p = splitHostPort(req.Host)
 		}
 	}
 	hostPort := requiredHTTPPort(req.TLS != nil, p)
 	if hostPort > 0 {
 		n++
 	}
 	attrs := make([]attribute.KeyValue, 0, n)
 	attrs = append(attrs, c.methodMetric(req.Method))
 	attrs = append(attrs, c.scheme(req.TLS != nil))
 	attrs = append(attrs, c.flavor(req.Proto))
 	attrs = append(attrs, c.NetConv.HostName(host))
 	if hostPort > 0 {
 		attrs = append(attrs, c.NetConv.HostPort(hostPort))
 	}
 	return attrs
 }
 func (c *httpConv) method(method string) attribute.KeyValue {
 	if method == "" {
 		return c.HTTPMethodKey.String(http.MethodGet)
 	}
 	return c.HTTPMethodKey.String(method)
 }
 func (c *httpConv) methodMetric(method string) attribute.KeyValue {
 	method = strings.ToUpper(method)
 	switch method {
 	case http.MethodConnect, http.MethodDelete, http.MethodGet, http.MethodHead, http.MethodOptions, http.MethodPatch, http.MethodPost, http.MethodPut, http.MethodTrace:
 	default:
 		method = "_OTHER"
 	}
 	return c.HTTPMethodKey.String(method)
 }
 func (c *httpConv) scheme(https bool) attribute.KeyValue { // nolint:revive
 	if https {
 		return c.HTTPSchemeHTTPS
 	}
 	return c.HTTPSchemeHTTP
 }
 func (c *httpConv) flavor(proto string) attribute.KeyValue {
 	switch proto {
 	case "HTTP/1.0":
 		return c.HTTPFlavorKey.String("1.0")
 	case "HTTP/1.1":
 		return c.HTTPFlavorKey.String("1.1")
 	case "HTTP/2":
 		return c.HTTPFlavorKey.String("2.0")
 	case "HTTP/3":
 		return c.HTTPFlavorKey.String("3.0")
 	default:
 		return c.HTTPFlavorKey.String(proto)
 	}
 }
 func serverClientIP(xForwardedFor string) string {
 	if idx := strings.Index(xForwardedFor, ","); idx >= 0 {
 		xForwardedFor = xForwardedFor[:idx]
 	}
 	return xForwardedFor
 }
 func requiredHTTPPort(https bool, port int) int { // nolint:revive
 	if https {
 		if port > 0 && port != 443 {
 			return port
 		}
 	} else {
 		if port > 0 && port != 80 {
 			return port
 		}
 	}
 	return -1
 }
 // Return the request host and port from the first non-empty source.
 func firstHostPort(source ...string) (host string, port int) {
 	for _, hostport := range source {
 		host, port = splitHostPort(hostport)
 		if host != "" || port > 0 {
 			break
 		}
 	}
 	return
 }
 // RequestHeader returns the contents of h as OpenTelemetry attributes.
 func (c *httpConv) RequestHeader(h http.Header) []attribute.KeyValue {
 	return c.header("http.request.header", h)
 }
 // ResponseHeader returns the contents of h as OpenTelemetry attributes.
 func (c *httpConv) ResponseHeader(h http.Header) []attribute.KeyValue {
 	return c.header("http.response.header", h)
 }
 func (c *httpConv) header(prefix string, h http.Header) []attribute.KeyValue {
 	key := func(k string) attribute.Key {
 		k = strings.ToLower(k)
 		k = strings.ReplaceAll(k, "-", "_")
 		k = fmt.Sprintf("%s.%s", prefix, k)
 		return attribute.Key(k)
 	}
 	attrs := make([]attribute.KeyValue, 0, len(h))
 	for k, v := range h {
 		attrs = append(attrs, key(k).StringSlice(v))
 	}
 	return attrs
 }
 // ClientStatus returns a span status code and message for an HTTP status code
 // value received by a client.
 func (c *httpConv) ClientStatus(code int) (codes.Code, string) {
 	if code < 100 || code >= 600 {
 		return codes.Error, fmt.Sprintf("Invalid HTTP status code %d", code)
 	}
 	if code >= 400 {
 		return codes.Error, ""
 	}
 	return codes.Unset, ""
 }
 // ServerStatus returns a span status code and message for an HTTP status code
 // value returned by a server. Status codes in the 400-499 range are not
 // returned as errors.
 func (c *httpConv) ServerStatus(code int) (codes.Code, string) {
 	if code < 100 || code >= 600 {
 		return codes.Error, fmt.Sprintf("Invalid HTTP status code %d", code)
 	}
 	if code >= 500 {
 		return codes.Error, ""
 	}
 	return codes.Unset, ""
 }
--- a/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil/netconv.go
+++ b/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil/netconv.go
@ -0,0 +1,368 @@
 // Code created by gotmpl. DO NOT MODIFY.
 // source: internal/shared/semconvutil/netconv.go.tmpl
 // 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 semconvutil // import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil"
 import (
 	"net"
 	"strconv"
 	"strings"
 	"go.opentelemetry.io/otel/attribute"
 	semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
 )
 // NetTransport returns a trace attribute describing the transport protocol of the
 // passed network. See the net.Dial for information about acceptable network
 // values.
 func NetTransport(network string) attribute.KeyValue {
 	return nc.Transport(network)
 }
 // NetClient returns trace attributes for a client network connection to address.
 // See net.Dial for information about acceptable address values, address should
 // be the same as the one used to create conn. If conn is nil, only network
 // peer attributes will be returned that describe address. Otherwise, the
 // socket level information about conn will also be included.
 func NetClient(address string, conn net.Conn) []attribute.KeyValue {
 	return nc.Client(address, conn)
 }
 // NetServer returns trace attributes for a network listener listening at address.
 // See net.Listen for information about acceptable address values, address
 // should be the same as the one used to create ln. If ln is nil, only network
 // host attributes will be returned that describe address. Otherwise, the
 // socket level information about ln will also be included.
 func NetServer(address string, ln net.Listener) []attribute.KeyValue {
 	return nc.Server(address, ln)
 }
 // netConv are the network semantic convention attributes defined for a version
 // of the OpenTelemetry specification.
 type netConv struct {
 	NetHostNameKey     attribute.Key
 	NetHostPortKey     attribute.Key
 	NetPeerNameKey     attribute.Key
 	NetPeerPortKey     attribute.Key
 	NetSockFamilyKey   attribute.Key
 	NetSockPeerAddrKey attribute.Key
 	NetSockPeerPortKey attribute.Key
 	NetSockHostAddrKey attribute.Key
 	NetSockHostPortKey attribute.Key
 	NetTransportOther  attribute.KeyValue
 	NetTransportTCP    attribute.KeyValue
 	NetTransportUDP    attribute.KeyValue
 	NetTransportInProc attribute.KeyValue
 }
 var nc = &netConv{
 	NetHostNameKey:     semconv.NetHostNameKey,
 	NetHostPortKey:     semconv.NetHostPortKey,
 	NetPeerNameKey:     semconv.NetPeerNameKey,
 	NetPeerPortKey:     semconv.NetPeerPortKey,
 	NetSockFamilyKey:   semconv.NetSockFamilyKey,
 	NetSockPeerAddrKey: semconv.NetSockPeerAddrKey,
 	NetSockPeerPortKey: semconv.NetSockPeerPortKey,
 	NetSockHostAddrKey: semconv.NetSockHostAddrKey,
 	NetSockHostPortKey: semconv.NetSockHostPortKey,
 	NetTransportOther:  semconv.NetTransportOther,
 	NetTransportTCP:    semconv.NetTransportTCP,
 	NetTransportUDP:    semconv.NetTransportUDP,
 	NetTransportInProc: semconv.NetTransportInProc,
 }
 func (c *netConv) Transport(network string) attribute.KeyValue {
 	switch network {
 	case "tcp", "tcp4", "tcp6":
 		return c.NetTransportTCP
 	case "udp", "udp4", "udp6":
 		return c.NetTransportUDP
 	case "unix", "unixgram", "unixpacket":
 		return c.NetTransportInProc
 	default:
 		// "ip:*", "ip4:*", and "ip6:*" all are considered other.
 		return c.NetTransportOther
 	}
 }
 // Host returns attributes for a network host address.
 func (c *netConv) Host(address string) []attribute.KeyValue {
 	h, p := splitHostPort(address)
 	var n int
 	if h != "" {
 		n++
 		if p > 0 {
 			n++
 		}
 	}
 	if n == 0 {
 		return nil
 	}
 	attrs := make([]attribute.KeyValue, 0, n)
 	attrs = append(attrs, c.HostName(h))
 	if p > 0 {
 		attrs = append(attrs, c.HostPort(int(p)))
 	}
 	return attrs
 }
 // Server returns attributes for a network listener listening at address. See
 // net.Listen for information about acceptable address values, address should
 // be the same as the one used to create ln. If ln is nil, only network host
 // attributes will be returned that describe address. Otherwise, the socket
 // level information about ln will also be included.
 func (c *netConv) Server(address string, ln net.Listener) []attribute.KeyValue {
 	if ln == nil {
 		return c.Host(address)
 	}
 	lAddr := ln.Addr()
 	if lAddr == nil {
 		return c.Host(address)
 	}
 	hostName, hostPort := splitHostPort(address)
 	sockHostAddr, sockHostPort := splitHostPort(lAddr.String())
 	network := lAddr.Network()
 	sockFamily := family(network, sockHostAddr)
 	n := nonZeroStr(hostName, network, sockHostAddr, sockFamily)
 	n += positiveInt(hostPort, sockHostPort)
 	attr := make([]attribute.KeyValue, 0, n)
 	if hostName != "" {
 		attr = append(attr, c.HostName(hostName))
 		if hostPort > 0 {
 			// Only if net.host.name is set should net.host.port be.
 			attr = append(attr, c.HostPort(hostPort))
 		}
 	}
 	if network != "" {
 		attr = append(attr, c.Transport(network))
 	}
 	if sockFamily != "" {
 		attr = append(attr, c.NetSockFamilyKey.String(sockFamily))
 	}
 	if sockHostAddr != "" {
 		attr = append(attr, c.NetSockHostAddrKey.String(sockHostAddr))
 		if sockHostPort > 0 {
 			// Only if net.sock.host.addr is set should net.sock.host.port be.
 			attr = append(attr, c.NetSockHostPortKey.Int(sockHostPort))
 		}
 	}
 	return attr
 }
 func (c *netConv) HostName(name string) attribute.KeyValue {
 	return c.NetHostNameKey.String(name)
 }
 func (c *netConv) HostPort(port int) attribute.KeyValue {
 	return c.NetHostPortKey.Int(port)
 }
 // Client returns attributes for a client network connection to address. See
 // net.Dial for information about acceptable address values, address should be
 // the same as the one used to create conn. If conn is nil, only network peer
 // attributes will be returned that describe address. Otherwise, the socket
 // level information about conn will also be included.
 func (c *netConv) Client(address string, conn net.Conn) []attribute.KeyValue {
 	if conn == nil {
 		return c.Peer(address)
 	}
 	lAddr, rAddr := conn.LocalAddr(), conn.RemoteAddr()
 	var network string
 	switch {
 	case lAddr != nil:
 		network = lAddr.Network()
 	case rAddr != nil:
 		network = rAddr.Network()
 	default:
 		return c.Peer(address)
 	}
 	peerName, peerPort := splitHostPort(address)
 	var (
 		sockFamily   string
 		sockPeerAddr string
 		sockPeerPort int
 		sockHostAddr string
 		sockHostPort int
 	)
 	if lAddr != nil {
 		sockHostAddr, sockHostPort = splitHostPort(lAddr.String())
 	}
 	if rAddr != nil {
 		sockPeerAddr, sockPeerPort = splitHostPort(rAddr.String())
 	}
 	switch {
 	case sockHostAddr != "":
 		sockFamily = family(network, sockHostAddr)
 	case sockPeerAddr != "":
 		sockFamily = family(network, sockPeerAddr)
 	}
 	n := nonZeroStr(peerName, network, sockPeerAddr, sockHostAddr, sockFamily)
 	n += positiveInt(peerPort, sockPeerPort, sockHostPort)
 	attr := make([]attribute.KeyValue, 0, n)
 	if peerName != "" {
 		attr = append(attr, c.PeerName(peerName))
 		if peerPort > 0 {
 			// Only if net.peer.name is set should net.peer.port be.
 			attr = append(attr, c.PeerPort(peerPort))
 		}
 	}
 	if network != "" {
 		attr = append(attr, c.Transport(network))
 	}
 	if sockFamily != "" {
 		attr = append(attr, c.NetSockFamilyKey.String(sockFamily))
 	}
 	if sockPeerAddr != "" {
 		attr = append(attr, c.NetSockPeerAddrKey.String(sockPeerAddr))
 		if sockPeerPort > 0 {
 			// Only if net.sock.peer.addr is set should net.sock.peer.port be.
 			attr = append(attr, c.NetSockPeerPortKey.Int(sockPeerPort))
 		}
 	}
 	if sockHostAddr != "" {
 		attr = append(attr, c.NetSockHostAddrKey.String(sockHostAddr))
 		if sockHostPort > 0 {
 			// Only if net.sock.host.addr is set should net.sock.host.port be.
 			attr = append(attr, c.NetSockHostPortKey.Int(sockHostPort))
 		}
 	}
 	return attr
 }
 func family(network, address string) string {
 	switch network {
 	case "unix", "unixgram", "unixpacket":
 		return "unix"
 	default:
 		if ip := net.ParseIP(address); ip != nil {
 			if ip.To4() == nil {
 				return "inet6"
 			}
 			return "inet"
 		}
 	}
 	return ""
 }
 func nonZeroStr(strs ...string) int {
 	var n int
 	for _, str := range strs {
 		if str != "" {
 			n++
 		}
 	}
 	return n
 }
 func positiveInt(ints ...int) int {
 	var n int
 	for _, i := range ints {
 		if i > 0 {
 			n++
 		}
 	}
 	return n
 }
 // Peer returns attributes for a network peer address.
 func (c *netConv) Peer(address string) []attribute.KeyValue {
 	h, p := splitHostPort(address)
 	var n int
 	if h != "" {
 		n++
 		if p > 0 {
 			n++
 		}
 	}
 	if n == 0 {
 		return nil
 	}
 	attrs := make([]attribute.KeyValue, 0, n)
 	attrs = append(attrs, c.PeerName(h))
 	if p > 0 {
 		attrs = append(attrs, c.PeerPort(int(p)))
 	}
 	return attrs
 }
 func (c *netConv) PeerName(name string) attribute.KeyValue {
 	return c.NetPeerNameKey.String(name)
 }
 func (c *netConv) PeerPort(port int) attribute.KeyValue {
 	return c.NetPeerPortKey.Int(port)
 }
 func (c *netConv) SockPeerAddr(addr string) attribute.KeyValue {
 	return c.NetSockPeerAddrKey.String(addr)
 }
 func (c *netConv) SockPeerPort(port int) attribute.KeyValue {
 	return c.NetSockPeerPortKey.Int(port)
 }
 // splitHostPort splits a network address hostport of the form "host",
 // "host%zone", "[host]", "[host%zone], "host:port", "host%zone:port",
 // "[host]:port", "[host%zone]:port", or ":port" into host or host%zone and
 // port.
 //
 // An empty host is returned if it is not provided or unparsable. A negative
 // port is returned if it is not provided or unparsable.
 func splitHostPort(hostport string) (host string, port int) {
 	port = -1
 	if strings.HasPrefix(hostport, "[") {
 		addrEnd := strings.LastIndex(hostport, "]")
 		if addrEnd < 0 {
 			// Invalid hostport.
 			return
 		}
 		if i := strings.LastIndex(hostport[addrEnd:], ":"); i < 0 {
 			host = hostport[1:addrEnd]
 			return
 		}
 	} else {
 		if i := strings.LastIndex(hostport, ":"); i < 0 {
 			host = hostport
 			return
 		}
 	}
 	host, pStr, err := net.SplitHostPort(hostport)
 	if err != nil {
 		return
 	}
 	p, err := strconv.ParseUint(pStr, 10, 16)
 	if err != nil {
 		return
 	}
 	return host, int(p)
 }
--- a/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/mux.go
+++ b/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/mux.go
@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
-package otelmux
+package otelmux // import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
 import (
 	"fmt"
@ -22,12 +22,11 @@ import (
 	"github.com/felixge/httpsnoop"
 	"github.com/gorilla/mux"
-	otelcontrib "go.opentelemetry.io/contrib"
+	"go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil"
 	"go.opentelemetry.io/otel"
 	"go.opentelemetry.io/otel/propagation"
-	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.17.0"
-	oteltrace "go.opentelemetry.io/otel/trace"
+	"go.opentelemetry.io/otel/trace"
 )
 const (
@ -47,26 +46,38 @@ func Middleware(service string, opts ...Option) mux.MiddlewareFunc {
 	}
 	tracer := cfg.TracerProvider.Tracer(
 		tracerName,
-		oteltrace.WithInstrumentationVersion(otelcontrib.SemVersion()),
+		trace.WithInstrumentationVersion(Version()),
 	)
 	if cfg.Propagators == nil {
 		cfg.Propagators = otel.GetTextMapPropagator()
 	}
 	if cfg.spanNameFormatter == nil {
 		cfg.spanNameFormatter = defaultSpanNameFunc
 	}
 	return func(handler http.Handler) http.Handler {
 		return traceware{
 			service:           service,
 			tracer:            tracer,
 			propagators:       cfg.Propagators,
 			handler:           handler,
 			spanNameFormatter: cfg.spanNameFormatter,
 			publicEndpoint:    cfg.PublicEndpoint,
 			publicEndpointFn:  cfg.PublicEndpointFn,
 			filters:           cfg.Filters,
 		}
 	}
 }
 type traceware struct {
 	service           string
-	tracer      oteltrace.Tracer
+	tracer            trace.Tracer
 	propagators       propagation.TextMapPropagator
 	handler           http.Handler
 	spanNameFormatter func(string, *http.Request) string
 	publicEndpoint    bool
 	publicEndpointFn  func(*http.Request) bool
 	filters           []Filter
 }
 type recordingResponseWriter struct {
@ -84,13 +95,12 @@ var rrwPool = &sync.Pool{
 func getRRW(writer http.ResponseWriter) *recordingResponseWriter {
 	rrw := rrwPool.Get().(*recordingResponseWriter)
 	rrw.written = false
-	rrw.status = 0
+	rrw.status = http.StatusOK
 	rrw.writer = httpsnoop.Wrap(writer, httpsnoop.Hooks{
 		Write: func(next httpsnoop.WriteFunc) httpsnoop.WriteFunc {
 			return func(b []byte) (int, error) {
 				if !rrw.written {
 					rrw.written = true
 					rrw.status = http.StatusOK
 				}
 				return next(b)
 			}
@ -113,40 +123,62 @@ func putRRW(rrw *recordingResponseWriter) {
 	rrwPool.Put(rrw)
 }
 // defaultSpanNameFunc just reuses the route name as the span name.
 func defaultSpanNameFunc(routeName string, _ *http.Request) string { return routeName }
 // ServeHTTP implements the http.Handler interface. It does the actual
 // tracing of the request.
 func (tw traceware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	for _, f := range tw.filters {
 		if !f(r) {
 			// Simply pass through to the handler if a filter rejects the request
 			tw.handler.ServeHTTP(w, r)
 			return
 		}
 	}
 	ctx := tw.propagators.Extract(r.Context(), propagation.HeaderCarrier(r.Header))
-	spanName := ""
+	routeStr := ""
 	route := mux.CurrentRoute(r)
 	if route != nil {
 		var err error
-		spanName, err = route.GetPathTemplate()
+		routeStr, err = route.GetPathTemplate()
 		if err != nil {
-			spanName, err = route.GetPathRegexp()
+			routeStr, err = route.GetPathRegexp()
 			if err != nil {
-				spanName = ""
+				routeStr = ""
 			}
 		}
 	}
-	routeStr := spanName
+
-	if spanName == "" {
+	opts := []trace.SpanStartOption{
-		spanName = fmt.Sprintf("HTTP %s route not found", r.Method)
+		trace.WithAttributes(semconvutil.HTTPServerRequest(tw.service, r)...),
 		trace.WithSpanKind(trace.SpanKindServer),
 	}
-	opts := []oteltrace.SpanStartOption{
+
-		oteltrace.WithAttributes(semconv.NetAttributesFromHTTPRequest("tcp", r)...),
+	if tw.publicEndpoint || (tw.publicEndpointFn != nil && tw.publicEndpointFn(r.WithContext(ctx))) {
-		oteltrace.WithAttributes(semconv.EndUserAttributesFromHTTPRequest(r)...),
+		opts = append(opts, trace.WithNewRoot())
-		oteltrace.WithAttributes(semconv.HTTPServerAttributesFromHTTPRequest(tw.service, routeStr, r)...),
+		// Linking incoming span context if any for public endpoint.
-		oteltrace.WithSpanKind(oteltrace.SpanKindServer),
+		if s := trace.SpanContextFromContext(ctx); s.IsValid() && s.IsRemote() {
 			opts = append(opts, trace.WithLinks(trace.Link{SpanContext: s}))
 		}
 	}
 	if routeStr == "" {
 		routeStr = fmt.Sprintf("HTTP %s route not found", r.Method)
 	} else {
 		rAttr := semconv.HTTPRoute(routeStr)
 		opts = append(opts, trace.WithAttributes(rAttr))
 	}
 	spanName := tw.spanNameFormatter(routeStr, r)
 	ctx, span := tw.tracer.Start(ctx, spanName, opts...)
 	defer span.End()
 	r2 := r.WithContext(ctx)
 	rrw := getRRW(w)
 	defer putRRW(rrw)
 	tw.handler.ServeHTTP(rrw.writer, r2)
-	attrs := semconv.HTTPAttributesFromHTTPStatusCode(rrw.status)
+	if rrw.status > 0 {
-	spanStatus, spanMessage := semconv.SpanStatusFromHTTPStatusCode(rrw.status)
+		span.SetAttributes(semconv.HTTPStatusCode(rrw.status))
-	span.SetAttributes(attrs...)
+	}
-	span.SetStatus(spanStatus, spanMessage)
+	span.SetStatus(semconvutil.HTTPServerStatus(rrw.status))
 }
--- a/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/version.go
+++ b/src/vendor/go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/version.go
@ -12,17 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// Package contrib contains common values used across all
+package otelmux // import "go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux"
 // instrumentation, exporter, and detector contributions.
 package contrib // import "go.opentelemetry.io/contrib"
-// Version is the current release version of OpenTelemetry Contrib in use.
+// Version is the current release version of the gorilla/mux instrumentation.
 func Version() string {
-	return "0.22.0"
+	return "0.45.0"
 	// This string is updated by the pre_release.sh script during release
 }
 // SemVersion is the semantic version to be supplied to tracer/meter creation.
 //
 // Deprecated: Use [Version] instead.
 func SemVersion() string {
-	return "semver:" + Version()
+	return Version()
 }
--- a/src/vendor/go.opentelemetry.io/contrib/pre_release.sh
+++ b/src/vendor/go.opentelemetry.io/contrib/pre_release.sh
@ -1,164 +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.
 #
 # This script is used for
 # a) creating a new tagged release of go.opentelemetry.io/contrib
 # b) bumping the referenced version of go.opentelemetry.io/otel
 #
 # The options can be used together or individually.
 #
 set -e
 declare CONTRIB_TAG
 declare OTEL_TAG
 declare PREV_OTEL_TAG
 help() {
   printf "\n"
   printf "Usage: %s [-o otel_tag] [-t tag]\n" "$0"
   printf "\t-o Otel release tag. Update all go.mod to reference go.opentelemetry.io/otel <otel_tag>.\n"
   printf "\t-p Previous Otel release tag. Update all go.mod that reference go.opentelemetry.io/otel <prev_otel_tag>.\n"
   printf "\t-t New Contrib unreleased tag. Update all go.mod files with this tag.\n"
   exit 1 # Exit script after printing help
 }
 while getopts "t:o:p:" opt
 do
   case "$opt" in
      t ) CONTRIB_TAG="$OPTARG" ;;
      o ) OTEL_TAG="$OPTARG" ;;
      p ) PREV_OTEL_TAG="$OPTARG" ;;
      ? ) help ;; # Print help
   esac
 done
 declare -r 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-]+)*)?$"
 validate_tag() {
    local newTag=$1
    if [[ "${newTag}" =~ ${SEMVER_REGEX} ]]; then
 	    printf "%s is valid semver tag.\n" "${newTag}"
    else
 	    printf "%s is not a valid semver tag.\n" "${newTag}"
 	    return 1
    fi
 }
 # Print help in case parameters are empty
 if [[ -z "$CONTRIB_TAG" && -z "$OTEL_TAG" ]]
 then
    printf "At least one of '-o' or '-t' must be specified.\n"
    help
 fi
 ## Validate tags first
 if [ -n "${OTEL_TAG}" ]; then
    validate_tag "${OTEL_TAG}" || exit $?
    # check that OTEL_TAG is a currently released tag for go.opentelemetry.io/otel
    TMPDIR=$(mktemp -d "/tmp/otel-contrib.XXXXXX") || exit 1
    trap "rm -fr ${TMPDIR}" EXIT
    (cd "${TMPDIR}" && go mod init tagtest)
    # requires go 1.14 for support of '-modfile'
    if ! go get -modfile="${TMPDIR}/go.mod" -d -v "go.opentelemetry.io/otel@${OTEL_TAG}"; then
        printf "go.opentelemetry.io/otel %s does not exist. Please supply a valid tag\n" "${OTEL_TAG}"
        exit 1
    fi
 fi
 if [ -n "${CONTRIB_TAG}" ]; then
    validate_tag "${CONTRIB_TAG}" || exit $?
    TAG_FOUND=$(git tag --list "${CONTRIB_TAG}")
    if [[ ${TAG_FOUND} = "${CONTRIB_TAG}" ]] ; then
        printf "Tag %s already exists in this repo\n" "${CONTRIB_TAG}"
        exit 1
    fi
 else
    CONTRIB_TAG=${OTEL_TAG}  # if contrib_tag not specified, but OTEL_TAG is, then set it to OTEL_TAG
 fi
 # Get version for contrib.go
 OTEL_CONTRIB_VERSION=$(echo "${CONTRIB_TAG}" | egrep -o "${SEMVER_REGEX}")
 # Strip leading v
 OTEL_CONTRIB_VERSION="${OTEL_CONTRIB_VERSION#v}"
 cd "$(dirname "$0")"
 if ! git diff --quiet; then \
    printf "Working tree is not clean, can't proceed\n"
    git status
    git diff
    exit 1
 fi
 # Update contrib.go version definition
 cp contrib.go contrib.go.bak
 sed "s/\(return \"\)[0-9]*\.[0-9]*\.[0-9]*\"/\1${OTEL_CONTRIB_VERSION}\"/" ./contrib.go.bak > ./contrib.go
 rm -f ./contrib.go.bak
 declare -r BRANCH_NAME=pre_release_${CONTRIB_TAG}
 defaultFromTag="v[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*[^0-9]*.*"
 patch_gomods() {
    local pkg_=$1
    local oldTag=${2:-$defaultFromTag}
    local newTag=$3
    # now do the same for all the directories underneath
    PACKAGE_DIRS=$(find . -mindepth 2 -type f -name 'go.mod' -exec dirname {} \; | egrep -v 'tools' | sed 's|^\.\/||' | sort)
    # quote any '.' characters in the pkg name
    local quoted_pkg_=${pkg_//./\\.}
    for dir in $PACKAGE_DIRS; do
 	    cp "${dir}/go.mod" "${dir}/go.mod.bak"
 	    sed "s|${quoted_pkg_}\([^ ]*\) ${oldTag}$|${pkg_}\1 ${newTag}|" "${dir}/go.mod.bak" >"${dir}/go.mod"
 	    rm -f "${dir}/go.mod.bak"
    done
 }
 # branch off from existing main
 git checkout -b "${BRANCH_NAME}" main
 # Update go.mods
 if [ -n "${OTEL_TAG}" ]; then
    # first update the top most module
    go get "go.opentelemetry.io/otel@${OTEL_TAG}"
    patch_gomods go.opentelemetry.io/otel "${PREV_OTEL_TAG}" "${OTEL_TAG}"
 fi
 if [ -n "${CONTRIB_TAG}" ]; then
    patch_gomods go.opentelemetry.io/contrib "" "${CONTRIB_TAG}"
 fi
 git diff
 # Run lint to update go.sum
 make lint
 # Add changes and commit.
 git add .
 make ci
 # Check whether registry links are up to date
 make registry-links-check
 declare COMMIT_MSG=""
 if [ -n "${OTEL_TAG}" ]; then
    COMMIT_MSG+="Bumping otel version to ${OTEL_TAG}"
 fi
 COMMIT_MSG+=".  Prepare for releasing ${CONTRIB_TAG}"
 git commit -m "${COMMIT_MSG}"
 printf "Now run following to verify the changes.\ngit diff main\n"
 printf "\nThen push the changes to upstream\n"
--- a/src/vendor/go.opentelemetry.io/contrib/tag.sh
+++ b/src/vendor/go.opentelemetry.io/contrib/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="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/src/vendor/modules.txt
+++ b/src/vendor/modules.txt
@ -581,12 +581,10 @@ go.mongodb.org/mongo-driver/bson/bsonrw
 go.mongodb.org/mongo-driver/bson/bsontype
 go.mongodb.org/mongo-driver/bson/primitive
 go.mongodb.org/mongo-driver/x/bsonx/bsoncore
-# go.opentelemetry.io/contrib v0.22.0
+# go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.45.0
-## explicit; go 1.15
+## explicit; go 1.19
 go.opentelemetry.io/contrib
 # go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux v0.22.0
 ## explicit; go 1.15
 go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux
 go.opentelemetry.io/contrib/instrumentation/github.com/gorilla/mux/otelmux/internal/semconvutil
 # go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.45.0
 ## explicit; go 1.19
 go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp