Merge pull request #29 from ultravioletrs/NOISSUE-servicelayertracing

NOISSUE - Add Service Layer Tracing

agent/api/grpc/client.go

@@ -6,9 +6,7 @@ import (
 	"time"
 
 	"github.com/go-kit/kit/endpoint"
-	kitot "github.com/go-kit/kit/tracing/opentracing"
 	kitgrpc "github.com/go-kit/kit/transport/grpc"
-	"github.com/opentracing/opentracing-go"
 	"github.com/ultravioletrs/agent/agent"
 	"google.golang.org/grpc"
 )
@@ -26,40 +24,40 @@ type grpcClient struct {
 }
 
 // NewClient returns new gRPC client instance.
-func NewClient(tracer opentracing.Tracer, conn *grpc.ClientConn, timeout time.Duration) agent.AgentServiceClient {
+func NewClient(conn *grpc.ClientConn, timeout time.Duration) agent.AgentServiceClient {
 	return &grpcClient{
-		run: kitot.TraceClient(tracer, "run")(kitgrpc.NewClient(
+		run: kitgrpc.NewClient(
 			conn,
 			svcName,
 			"Run",
 			encodeRunRequest,
 			decodeRunResponse,
 			agent.RunResponse{},
-		).Endpoint()),
-		algo: kitot.TraceClient(tracer, "algo")(kitgrpc.NewClient(
+		).Endpoint(),
+		algo: kitgrpc.NewClient(
 			conn,
 			svcName,
 			"Algo",
 			encodeAlgoRequest,
 			decodeAlgoResponse,
 			agent.AlgoResponse{},
-		).Endpoint()),
-		data: kitot.TraceClient(tracer, "data")(kitgrpc.NewClient(
+		).Endpoint(),
+		data: kitgrpc.NewClient(
 			conn,
 			svcName,
 			"Data",
 			encodeDataRequest,
 			decodeDataResponse,
 			agent.DataResponse{},
-		).Endpoint()),
-		result: kitot.TraceClient(tracer, "result")(kitgrpc.NewClient(
+		).Endpoint(),
+		result: kitgrpc.NewClient(
 			conn,
 			svcName,
 			"Result",
 			encodeResultRequest,
 			decodeResultResponse,
 			agent.ResultResponse{},
-		).Endpoint()),
+		).Endpoint(),
 		timeout: timeout,
 	}
 }

agent/api/grpc/server.go

@@ -3,9 +3,7 @@ package grpc
 import (
 	"context"
 
-	kitot "github.com/go-kit/kit/tracing/opentracing"
 	kitgrpc "github.com/go-kit/kit/transport/grpc"
-	"github.com/opentracing/opentracing-go"
 	"github.com/ultravioletrs/agent/agent"
 )
 
@@ -18,25 +16,25 @@ type grpcServer struct {
 }
 
 // NewServer returns new AgentServiceServer instance.
-func NewServer(tracer opentracing.Tracer, svc agent.Service) agent.AgentServiceServer {
+func NewServer(svc agent.Service) agent.AgentServiceServer {
 	return &grpcServer{
 		run: kitgrpc.NewServer(
-			kitot.TraceServer(tracer, "run")(runEndpoint(svc)),
+			runEndpoint(svc),
 			decodeRunRequest,
 			encodeRunResponse,
 		),
 		algo: kitgrpc.NewServer(
-			kitot.TraceServer(tracer, "algo")(algoEndpoint(svc)),
+			algoEndpoint(svc),
 			decodeAlgoRequest,
 			encodeAlgoResponse,
 		),
 		data: kitgrpc.NewServer(
-			kitot.TraceServer(tracer, "data")(dataEndpoint(svc)),
+			dataEndpoint(svc),
 			decodeDataRequest,
 			encodeDataResponse,
 		),
 		result: kitgrpc.NewServer(
-			kitot.TraceServer(tracer, "result")(resultEndpoint(svc)),
+			resultEndpoint(svc),
 			decodeResultRequest,
 			encodeResultResponse,
 		),

agent/api/http/transport.go

@@ -11,13 +11,12 @@ import (
 	"net/http"
 	"strings"
 
-	kitot "github.com/go-kit/kit/tracing/opentracing"
 	kithttp "github.com/go-kit/kit/transport/http"
 	"github.com/go-zoo/bone"
 	"github.com/mainflux/mainflux"
-	opentracing "github.com/opentracing/opentracing-go"
 	"github.com/prometheus/client_golang/prometheus/promhttp"
 	agent "github.com/ultravioletrs/agent/agent"
+	"go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp"
 )
 
 const (
@@ -30,27 +29,27 @@ var (
 )
 
 // MakeHandler returns a HTTP handler for API endpoints.
-func MakeHandler(tracer opentracing.Tracer, svc agent.Service, instanceID string) http.Handler {
+func MakeHandler(svc agent.Service, instanceID string) http.Handler {
 	opts := []kithttp.ServerOption{
 		kithttp.ServerErrorEncoder(encodeError),
 	}
 
 	r := bone.New()
 
-	r.Post("/agent", kithttp.NewServer(
-		kitot.TraceServer(tracer, "ping")(pingEndpoint(svc)),
+	r.Post("/agent", otelhttp.NewHandler(kithttp.NewServer(
+		pingEndpoint(svc),
 		decodePing,
 		encodeResponse,
 		opts...,
-	))
-	r.Post("/run", kithttp.NewServer(
-		kitot.TraceServer(tracer, "run")(runEndpoint(svc)),
+	), "ping"))
+	r.Post("/run", otelhttp.NewHandler(kithttp.NewServer(
+		runEndpoint(svc),
 		decodeRun,
 		encodeResponse,
 		opts...,
-	))
+	), "run"))
 
-	r.GetFunc("/version", mainflux.Health("things", instanceID))
+	r.GetFunc("/version", mainflux.Health("agent", instanceID))
 	r.Handle("/metrics", promhttp.Handler())
 
 	return r

agent/tracing/doc.go

@@ -0,0 +1,9 @@
+// Package tracing provides tracing instrumentation for cocos auth service.
+//
+// This package provides tracing middleware for cocos auth service.
+// It can be used to trace incoming requests and add tracing capabilities to
+// cocos auth service.
+//
+// For more details about tracing instrumentation refer
+// to the documentation at https://docs.mainflux.io/tracing/.
+package tracing

agent/tracing/tracing.go

@@ -0,0 +1,70 @@
+package tracing
+
+import (
+	"context"
+
+	"github.com/ultravioletrs/agent/agent"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
+)
+
+var _ agent.Service = (*tracingMiddleware)(nil)
+
+type tracingMiddleware struct {
+	tracer trace.Tracer
+	svc    agent.Service
+}
+
+// New returns a new auth service with tracing capabilities.
+func New(svc agent.Service, tracer trace.Tracer) agent.Service {
+	return &tracingMiddleware{tracer, svc}
+}
+
+func (tm *tracingMiddleware) Ping(secret string) (string, error) {
+	_, span := tm.tracer.Start(context.Background(), "ping", trace.WithAttributes(
+		attribute.String("secret", secret),
+	))
+	defer span.End()
+
+	return tm.svc.Ping(secret)
+}
+
+func (tm *tracingMiddleware) Run(ctx context.Context, cmp agent.Computation) (string, error) {
+	ctx, span := tm.tracer.Start(ctx, "run", trace.WithAttributes(
+		attribute.String("id", cmp.ID),
+		attribute.String("name", cmp.Name),
+		attribute.String("description", cmp.Description),
+		attribute.String("status", cmp.Status),
+		attribute.String("start_time", cmp.StartTime.String()),
+		attribute.String("end_time", cmp.EndTime.String()),
+		attribute.StringSlice("dataset_providers", cmp.DatasetProviders),
+		attribute.StringSlice("algorithm_providers", cmp.AlgorithmProviders),
+		attribute.StringSlice("result_consumers", cmp.ResultConsumers),
+	))
+	defer span.End()
+
+	return tm.svc.Run(ctx, cmp)
+}
+
+func (tm *tracingMiddleware) Algo(ctx context.Context, algorithm []byte) (string, error) {
+	ctx, span := tm.tracer.Start(ctx, "algo")
+	defer span.End()
+
+	return tm.svc.Algo(ctx, algorithm)
+}
+
+func (tm *tracingMiddleware) Data(ctx context.Context, dataset string) (string, error) {
+	ctx, span := tm.tracer.Start(ctx, "data", trace.WithAttributes(
+		attribute.String("dataset", dataset),
+	))
+	defer span.End()
+
+	return tm.svc.Data(ctx, dataset)
+}
+
+func (tm *tracingMiddleware) Result(ctx context.Context) ([]byte, error) {
+	ctx, span := tm.tracer.Start(ctx, "result")
+	defer span.End()
+
+	return tm.svc.Result(ctx)
+}

cmd/agent/main.go

@@ -3,24 +3,23 @@ package main
 import (
 	"context"
 	"fmt"
-	"io"
-	"io/ioutil"
 	"log"
 	"os"
 
 	mflog "github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/pkg/uuid"
-	opentracing "github.com/opentracing/opentracing-go"
-	jconfig "github.com/uber/jaeger-client-go/config"
 	agent "github.com/ultravioletrs/agent/agent"
 	"github.com/ultravioletrs/agent/agent/api"
 	agentgrpc "github.com/ultravioletrs/agent/agent/api/grpc"
 	httpapi "github.com/ultravioletrs/agent/agent/api/http"
+	"github.com/ultravioletrs/agent/agent/tracing"
 	"github.com/ultravioletrs/agent/internal"
 	"github.com/ultravioletrs/agent/internal/env"
+	jaegerclient "github.com/ultravioletrs/agent/internal/jaeger"
 	"github.com/ultravioletrs/agent/internal/server"
 	grpcserver "github.com/ultravioletrs/agent/internal/server/grpc"
 	httpserver "github.com/ultravioletrs/agent/internal/server/http"
+	"go.opentelemetry.io/otel/trace"
 	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/reflection"
@@ -37,7 +36,7 @@ const (
 type config struct {
 	LogLevel   string `env:"AGENT_LOG_LEVEL"   envDefault:"info"`
 	Secret     string `env:"AGENT_SECRET"      envDefault:"secret"`
-	JaegerURL  string `env:"AGENT_JAEGER_URL"  envDefault:"localhost:14268/api/traces"`
+	JaegerURL  string `env:"AGENT_JAEGER_URL"  envDefault:"http://localhost:14268/api/traces"`
 	InstanceID string `env:"AGENT_INSTANCE_ID" envDefault:""`
 }
 
@@ -62,16 +61,24 @@ func main() {
 		}
 	}
 
-	agentTracer, agentCloser := initJaeger("agent", cfg.JaegerURL, logger)
-	defer agentCloser.Close()
+	tp, err := jaegerclient.NewProvider(ctx, svcName, cfg.JaegerURL, cfg.InstanceID)
+	if err != nil {
+		logger.Error(fmt.Sprintf("Failed to init Jaeger: %s", err))
+	}
+	defer func() {
+		if err := tp.Shutdown(ctx); err != nil {
+			logger.Error(fmt.Sprintf("Error shutting down tracer provider: %v", err))
+		}
+	}()
+	tracer := tp.Tracer(svcName)
 
-	svc := newService(cfg.Secret, logger)
+	svc := newService(cfg.Secret, logger, tracer)
 
 	var httpServerConfig = server.Config{Port: defSvcHTTPPort}
 	if err := env.Parse(&httpServerConfig, env.Options{Prefix: envPrefixHTTP}); err != nil {
 		logger.Fatal(fmt.Sprintf("failed to load %s gRPC server configuration : %s", svcName, err))
 	}
-	hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, httpapi.MakeHandler(agentTracer, svc, cfg.InstanceID), logger)
+	hs := httpserver.New(ctx, cancel, svcName, httpServerConfig, httpapi.MakeHandler(svc, cfg.InstanceID), logger)
 
 	var grpcServerConfig = server.Config{Port: defSvcGRPCPort}
 	if err := env.Parse(&grpcServerConfig, env.Options{Prefix: envPrefixGRPC}); err != nil {
@@ -79,7 +86,7 @@ func main() {
 	}
 	registerAgentServiceServer := func(srv *grpc.Server) {
 		reflection.Register(srv)
-		agent.RegisterAgentServiceServer(srv, agentgrpc.NewServer(agentTracer, svc))
+		agent.RegisterAgentServiceServer(srv, agentgrpc.NewServer(svc))
 	}
 	gs := grpcserver.New(ctx, cancel, svcName, grpcServerConfig, registerAgentServiceServer, logger)
 
@@ -100,36 +107,13 @@ func main() {
 	}
 }
 
-func initJaeger(svcName, url string, logger mflog.Logger) (opentracing.Tracer, io.Closer) {
-	if url == "" {
-		return opentracing.NoopTracer{}, ioutil.NopCloser(nil)
-	}
-
-	tracer, closer, err := jconfig.Configuration{
-		ServiceName: svcName,
-		Sampler: &jconfig.SamplerConfig{
-			Type:  "const",
-			Param: 1,
-		},
-		Reporter: &jconfig.ReporterConfig{
-			LocalAgentHostPort: url,
-			LogSpans:           true,
-		},
-	}.NewTracer()
-	if err != nil {
-		logger.Error(fmt.Sprintf("Failed to init Jaeger client: %s", err))
-		os.Exit(1)
-	}
-
-	return tracer, closer
-}
-
-func newService(secret string, logger mflog.Logger) agent.Service {
+func newService(secret string, logger mflog.Logger, tracer trace.Tracer) agent.Service {
 	svc := agent.New(secret)
 
 	svc = api.LoggingMiddleware(svc, logger)
 	counter, latency := internal.MakeMetrics(svcName, "api")
 	svc = api.MetricsMiddleware(svc, counter, latency)
+	svc = tracing.New(svc, tracer)
 
 	return svc
 }

cmd/cli/main.go

@@ -20,7 +20,7 @@ const (
 
 type config struct {
 	LogLevel  string `env:"AGENT_LOG_LEVEL"      envDefault:"info"`
-	JaegerURL string `env:"AGENT_JAEGER_URL"     envDefault:""`
+	JaegerURL string `env:"AGENT_JAEGER_URL"     envDefault:"http://localhost:14268/api/traces"`
 }
 
 func main() {

docker/.env

@@ -1,14 +1,21 @@
 # Docker: Environment variables in Compose
 
+## Jaeger
+AGENT_JAEGER_PORT=6831
+AGENT_JAEGER_FRONTEND=16686
+AGENT_JAEGER_COLLECTOR=14268
+AGENT_JAEGER_CONFIGS=5778
+AGENT_JAEGER_URL=http://jaeger:14268/api/traces
+
 ## Agent
 AGENT_LOG_LEVEL=info
 AGENT_SECRET=secret
 AGENT_JAEGER_URL=
-MF_AGENT_HTTP_HOST=
-MF_AGENT_HTTP_PORT=9031
-MF_AGENT_HTTP_SERVER_CERT=
-MF_AGENT_HTTP_SERVER_KEY=
-MF_AGENT_GRPC_HOST=
-MF_AGENT_GRPC_PORT=7002
-MF_AGENT_GRPC_SERVER_CERT=
-MF_AGENT_GRPC_SERVER_KEY=
+AGENT_HTTP_HOST=
+AGENT_HTTP_PORT=9031
+AGENT_HTTP_SERVER_CERT=
+AGENT_HTTP_SERVER_KEY=
+AGENT_GRPC_HOST=
+AGENT_GRPC_PORT=7002
+AGENT_GRPC_SERVER_CERT=
+AGENT_GRPC_SERVER_KEY=

docker/docker-compose.yml

@@ -9,22 +9,18 @@
 version: "3.7"
 
 networks:
-  docker_mainflux-base-net:
-    external: true
+  agent-net:
+    driver: bridge
 
 services:
-  mfxkit:
-    image: mainflux/mfxkit:latest
-    container_name: mainflux-mfxkit
-    restart: on-failure
-    environment:
-      MF_MFXKIT_LOG_LEVEL: ${MF_MFXKIT_LOG_LEVEL}
-      MF_MFXKIT_HTTP_PORT: ${MF_MFXKIT_HTTP_PORT}
-      MF_MFXKIT_SERVER_CERT: ${MF_MFXKIT_SERVER_CERT}
-      MF_MFXKIT_SERVER_KEY: ${MF_MFXKIT_SERVER_KEY}
-      MF_JAEGER_URL: ${MF_JAEGER_URL}
-      MF_MFXKIT_SECRET: ${MF_MFXKIT_SECRET}
+  jaeger:
+    image: jaegertracing/all-in-one:1.38.0
+    container_name: mainflux-jaeger
     ports:
-      - ${MF_MFXKIT_HTTP_PORT}:${MF_MFXKIT_HTTP_PORT}
+      - ${AGENT_JAEGER_PORT}:${AGENT_JAEGER_PORT}/udp
+      - ${AGENT_JAEGER_FRONTEND}:${AGENT_JAEGER_FRONTEND}
+      - ${AGENT_JAEGER_COLLECTOR}:${AGENT_JAEGER_COLLECTOR}
+      - ${AGENT_JAEGER_CONFIGS}:${AGENT_JAEGER_CONFIGS}
     networks:
-      - docker_mainflux-base-net
+      - agent-net
+

go.mod

@@ -7,11 +7,15 @@ require (
 	github.com/go-kit/kit v0.12.0
 	github.com/go-zoo/bone v1.3.0
 	github.com/mainflux/mainflux v0.0.0-20230722123816-70f53c2f979d
-	github.com/opentracing/opentracing-go v1.2.0
 	github.com/prometheus/client_golang v1.16.0
 	github.com/spf13/cobra v1.7.0
-	github.com/uber/jaeger-client-go v2.30.0+incompatible
 	go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.42.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.42.0
+	go.opentelemetry.io/contrib/propagators/jaeger v1.17.0
+	go.opentelemetry.io/otel v1.16.0
+	go.opentelemetry.io/otel/exporters/jaeger v1.16.0
+	go.opentelemetry.io/otel/sdk v1.16.0
+	go.opentelemetry.io/otel/trace v1.16.0
 	golang.org/x/sync v0.3.0
 	google.golang.org/grpc v1.56.1
 	google.golang.org/protobuf v1.31.0
@@ -20,6 +24,7 @@ require (
 require (
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.2.0 // indirect
+	github.com/felixge/httpsnoop v1.0.3 // indirect
 	github.com/go-kit/log v0.2.1 // indirect
 	github.com/go-logfmt/logfmt v0.6.0 // indirect
 	github.com/go-logr/logr v1.2.4 // indirect
@@ -28,17 +33,12 @@ require (
 	github.com/golang/protobuf v1.5.3 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/matttproud/golang_protobuf_extensions v1.0.4 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_model v0.4.0 // indirect
 	github.com/prometheus/common v0.44.0 // indirect
 	github.com/prometheus/procfs v0.11.0 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.4.2 // indirect
-	github.com/uber/jaeger-lib v2.4.1+incompatible // indirect
-	go.opentelemetry.io/otel v1.16.0 // indirect
 	go.opentelemetry.io/otel/metric v1.16.0 // indirect
-	go.opentelemetry.io/otel/trace v1.16.0 // indirect
-	go.uber.org/atomic v1.11.0 // indirect
 	golang.org/x/net v0.12.0 // indirect
 	golang.org/x/sys v0.10.0 // indirect
 	golang.org/x/text v0.11.0 // indirect

go.sum

@@ -1,7 +1,6 @@
 cloud.google.com/go v0.110.0 h1:Zc8gqp3+a9/Eyph2KDmcGaPtbKRIoqq4YTlL4NMD0Ys=
 cloud.google.com/go/compute v1.19.1 h1:am86mquDUgjGNWxiGn+5PGLbmgiWXlE/yNWpIpNvuXY=
 cloud.google.com/go/compute/metadata v0.2.3 h1:mg4jlk7mCAj6xXp9UJ4fjI9VUI5rubuGBW5aJ7UnBMY=
-github.com/HdrHistogram/hdrhistogram-go v1.1.2 h1:5IcZpTvzydCQeHzK4Ef/D5rrSqwxob0t8PQPMybUNFM=
 github.com/VividCortex/gohistogram v1.0.0 h1:6+hBz+qvs0JOrrNhhmR7lFxo5sINxBCGXrdtl/UvroE=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
@@ -11,9 +10,10 @@ github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj
 github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
 github.com/cncf/xds/go v0.0.0-20230607035331-e9ce68804cb4 h1:/inchEIKaYC1Akx+H+gqO04wryn5h75LSazbRlnya1k=
 github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/envoyproxy/protoc-gen-validate v0.10.1 h1:c0g45+xCJhdgFGw7a5QAfdS4byAbud7miNWJ1WwEVf8=
+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/go-kit/kit v0.12.0 h1:e4o3o3IsBfAKQh5Qbbiqyfu97Ku7jrO/JbohvztANh4=
 github.com/go-kit/kit v0.12.0/go.mod h1:lHd+EkCZPIwYItmGDDRdhinkzX2A1sj+M9biaEaizzs=
 github.com/go-kit/log v0.2.1 h1:MRVx0/zhvdseW+Gza6N9rVzU/IVzaeE1SFI4raAhmBU=
@@ -41,12 +41,7 @@ github.com/mainflux/mainflux v0.0.0-20230722123816-70f53c2f979d h1:Tn64WmXxPJAMZ
 github.com/mainflux/mainflux v0.0.0-20230722123816-70f53c2f979d/go.mod h1:FoeJ13mrfikrsFDW6bOb3C44D5gZ5m9Jt249G1sLKq0=
 github.com/matttproud/golang_protobuf_extensions v1.0.4 h1:mmDVorXM7PCGKw94cs5zkfA9PSy5pEvNWRP0ET0TIVo=
 github.com/matttproud/golang_protobuf_extensions v1.0.4/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4=
-github.com/opentracing/opentracing-go v1.2.0 h1:uEJPy/1a5RIPAJ0Ov+OIO8OxWu77jEv+1B0VhjKrZUs=
-github.com/opentracing/opentracing-go v1.2.0/go.mod h1:GxEUsuufX4nBwe+T+Wl9TAgYrxe9dPLANfrWvHYVTgc=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/prometheus/client_golang v1.16.0 h1:yk/hx9hDbrGHovbci4BY+pRMfSuuat626eFsHb7tmT8=
 github.com/prometheus/client_golang v1.16.0/go.mod h1:Zsulrv/L9oM40tJ7T815tM89lFEugiJ9HzIqaAx4LKc=
 github.com/prometheus/client_model v0.4.0 h1:5lQXD3cAg1OXBf4Wq03gTrXHeaV0TQvGfUooCfx1yqY=
@@ -60,26 +55,26 @@ github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
 github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
-github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8=
 github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0=
-github.com/uber/jaeger-client-go v2.30.0+incompatible h1:D6wyKGCecFaSRUpo8lCVbaOOb6ThwMmTEbhRwtKR97o=
-github.com/uber/jaeger-client-go v2.30.0+incompatible/go.mod h1:WVhlPFC8FDjOFMMWRy2pZqQJSXxYSwNYOkTr/Z6d3Kk=
-github.com/uber/jaeger-lib v2.4.1+incompatible h1:td4jdvLcExb4cBISKIpHuGoVXh+dVKhn2Um6rjCsSsg=
-github.com/uber/jaeger-lib v2.4.1+incompatible/go.mod h1:ComeNDZlWwrWnDv8aPp0Ba6+uUTzImX/AauajbLI56U=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.42.0 h1:ZOLJc06r4CB42laIXg/7udr0pbZyuAihN10A/XuiQRY=
 go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.42.0/go.mod h1:5z+/ZWJQKXa9YT34fQNx5K8Hd1EoIhvtUygUQPqEOgQ=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.42.0 h1:pginetY7+onl4qN1vl0xW/V/v6OBZ0vVdH+esuJgvmM=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.42.0/go.mod h1:XiYsayHc36K3EByOO6nbAXnAWbrUxdjUROCEeeROOH8=
+go.opentelemetry.io/contrib/propagators/jaeger v1.17.0 h1:Zbpbmwav32Ea5jSotpmkWEl3a6Xvd4tw/3xxGO1i05Y=
+go.opentelemetry.io/contrib/propagators/jaeger v1.17.0/go.mod h1:tcTUAlmO8nuInPDSBVfG+CP6Mzjy5+gNV4mPxMbL0IA=
 go.opentelemetry.io/otel v1.16.0 h1:Z7GVAX/UkAXPKsy94IU+i6thsQS4nb7LviLpnaNeW8s=
 go.opentelemetry.io/otel v1.16.0/go.mod h1:vl0h9NUa1D5s1nv3A5vZOYWn8av4K8Ml6JDeHrT/bx4=
+go.opentelemetry.io/otel/exporters/jaeger v1.16.0 h1:YhxxmXZ011C0aDZKoNw+juVWAmEfv/0W2XBOv9aHTaA=
+go.opentelemetry.io/otel/exporters/jaeger v1.16.0/go.mod h1:grYbBo/5afWlPpdPZYhyn78Bk04hnvxn2+hvxQhKIQM=
 go.opentelemetry.io/otel/metric v1.16.0 h1:RbrpwVG1Hfv85LgnZ7+txXioPDoh6EdbZHo26Q3hqOo=
 go.opentelemetry.io/otel/metric v1.16.0/go.mod h1:QE47cpOmkwipPiefDwo2wDzwJrlfxxNYodqc4xnGCo4=
+go.opentelemetry.io/otel/sdk v1.16.0 h1:Z1Ok1YsijYL0CSJpHt4cS3wDDh7p572grzNrBMiMWgE=
+go.opentelemetry.io/otel/sdk v1.16.0/go.mod h1:tMsIuKXuuIWPBAOrH+eHtvhTL+SntFtXF9QD68aP6p4=
 go.opentelemetry.io/otel/trace v1.16.0 h1:8JRpaObFoW0pxuVPapkgH8UhHQj+bJW8jJsCZEu5MQs=
 go.opentelemetry.io/otel/trace v1.16.0/go.mod h1:Yt9vYq1SdNz3xdjZZK7wcXv1qv2pwLkqr2QVwea0ef0=
-go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
-go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
 golang.org/x/net v0.12.0 h1:cfawfvKITfUsFCeJIHJrbSxpeu/E81khclypR0GVT50=
 golang.org/x/net v0.12.0/go.mod h1:zEVYFnQC7m/vmpQFELhcD1EWkZlX69l4oqgmer6hfKA=
 golang.org/x/oauth2 v0.8.0 h1:6dkIjl3j3LtZ/O3sTgZTMsLKSftL/B8Zgq4huOIIUu8=

internal/jaeger/doc.go

@@ -0,0 +1,3 @@
+// Package jaeger contains the domain concept definitions needed to support
+// Mainflux Jaeger functionality.
+package jaeger

internal/jaeger/provider.go

@@ -0,0 +1,62 @@
+// Copyright (c) Mainflux
+// SPDX-License-Identifier: Apache-2.0
+
+package jaeger
+
+import (
+	"context"
+	"errors"
+
+	jaegerp "go.opentelemetry.io/contrib/propagators/jaeger"
+	"go.opentelemetry.io/otel"
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/exporters/jaeger"
+	"go.opentelemetry.io/otel/sdk/resource"
+	tracesdk "go.opentelemetry.io/otel/sdk/trace"
+	semconv "go.opentelemetry.io/otel/semconv/v1.12.0"
+)
+
+var (
+	errNoURL     = errors.New("URL is empty")
+	errNoSvcName = errors.New("Service Name is empty")
+)
+
+// NewProvider initializes Jaeger TraceProvider.
+func NewProvider(ctx context.Context, svcName, url, instanceID string) (*tracesdk.TracerProvider, error) {
+	if url == "" {
+		return nil, errNoURL
+	}
+
+	if svcName == "" {
+		return nil, errNoSvcName
+	}
+
+	exporter, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(url)))
+	if err != nil {
+		return nil, err
+	}
+
+	attributes := []attribute.KeyValue{
+		semconv.ServiceNameKey.String(svcName),
+		attribute.String("InstanceID", instanceID),
+	}
+
+	hostAttr, err := resource.New(ctx, resource.WithHost(), resource.WithOSDescription(), resource.WithContainer())
+	if err != nil {
+		return nil, err
+	}
+	attributes = append(attributes, hostAttr.Attributes()...)
+
+	tp := tracesdk.NewTracerProvider(
+		tracesdk.WithSampler(tracesdk.AlwaysSample()),
+		tracesdk.WithBatcher(exporter),
+		tracesdk.WithResource(resource.NewWithAttributes(
+			semconv.SchemaURL,
+			attributes...,
+		)),
+	)
+	otel.SetTracerProvider(tp)
+	otel.SetTextMapPropagator(jaegerp.Jaeger{})
+
+	return tp, nil
+}

pkg/clients/grpc/agent.go

@@ -1,7 +1,6 @@
 package grpc
 
 import (
-	"github.com/opentracing/opentracing-go"
 	"github.com/ultravioletrs/agent/agent"
 	agentapi "github.com/ultravioletrs/agent/agent/api/grpc"
 )
@@ -13,5 +12,5 @@ func NewClient(cfg Config) (Client, agent.AgentServiceClient, error) {
 		return nil, nil, err
 	}
 
-	return client, agentapi.NewClient(opentracing.NoopTracer{}, client.Connection(), cfg.Timeout), nil
+	return client, agentapi.NewClient(client.Connection(), cfg.Timeout), nil
 }

vendor/github.com/felixge/httpsnoop/.travis.yml

@@ -0,0 +1,6 @@
+language: go
+
+go:
+  - 1.6
+  - 1.7
+  - 1.8

vendor/github.com/felixge/httpsnoop/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Felix Geisendörfer (felix@debuggable.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

vendor/github.com/felixge/httpsnoop/Makefile

@@ -0,0 +1,10 @@
+.PHONY: ci generate clean
+
+ci: clean generate
+	go test -v ./...
+
+generate:
+	go generate .
+
+clean:
+	rm -rf *_generated*.go

vendor/github.com/felixge/httpsnoop/README.md

@@ -0,0 +1,95 @@
+# httpsnoop
+
+Package httpsnoop provides an easy way to capture http related metrics (i.e.
+response time, bytes written, and http status code) from your application's
+http.Handlers.
+
+Doing this requires non-trivial wrapping of the http.ResponseWriter interface,
+which is also exposed for users interested in a more low-level API.
+
+[![GoDoc](https://godoc.org/github.com/felixge/httpsnoop?status.svg)](https://godoc.org/github.com/felixge/httpsnoop)
+[![Build Status](https://travis-ci.org/felixge/httpsnoop.svg?branch=master)](https://travis-ci.org/felixge/httpsnoop)
+
+## Usage Example
+
+```go
+// myH is your app's http handler, perhaps a http.ServeMux or similar.
+var myH http.Handler
+// wrappedH wraps myH in order to log every request.
+wrappedH := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	m := httpsnoop.CaptureMetrics(myH, w, r)
+	log.Printf(
+		"%s %s (code=%d dt=%s written=%d)",
+		r.Method,
+		r.URL,
+		m.Code,
+		m.Duration,
+		m.Written,
+	)
+})
+http.ListenAndServe(":8080", wrappedH)
+```
+
+## Why this package exists
+
+Instrumenting an application's http.Handler is surprisingly difficult.
+
+However if you google for e.g. "capture ResponseWriter status code" you'll find
+lots of advise and code examples that suggest it to be a fairly trivial
+undertaking. Unfortunately everything I've seen so far has a high chance of
+breaking your application.
+
+The main problem is that a `http.ResponseWriter` often implements additional
+interfaces such as `http.Flusher`, `http.CloseNotifier`, `http.Hijacker`, `http.Pusher`, and
+`io.ReaderFrom`. So the naive approach of just wrapping `http.ResponseWriter`
+in your own struct that also implements the `http.ResponseWriter` interface
+will hide the additional interfaces mentioned above. This has a high change of
+introducing subtle bugs into any non-trivial application.
+
+Another approach I've seen people take is to return a struct that implements
+all of the interfaces above. However, that's also problematic, because it's
+difficult to fake some of these interfaces behaviors when the underlying
+`http.ResponseWriter` doesn't have an implementation. It's also dangerous,
+because an application may choose to operate differently, merely because it
+detects the presence of these additional interfaces.
+
+This package solves this problem by checking which additional interfaces a
+`http.ResponseWriter` implements, returning a wrapped version implementing the
+exact same set of interfaces.
+
+Additionally this package properly handles edge cases such as `WriteHeader` not
+being called, or called more than once, as well as concurrent calls to
+`http.ResponseWriter` methods, and even calls happening after the wrapped
+`ServeHTTP` has already returned.
+
+Unfortunately this package is not perfect either. It's possible that it is
+still missing some interfaces provided by the go core (let me know if you find
+one), and it won't work for applications adding their own interfaces into the
+mix. You can however use `httpsnoop.Unwrap(w)` to access the underlying
+`http.ResponseWriter` and type-assert the result to its other interfaces.
+
+However, hopefully the explanation above has sufficiently scared you of rolling
+your own solution to this problem. httpsnoop may still break your application,
+but at least it tries to avoid it as much as possible.
+
+Anyway, the real problem here is that smuggling additional interfaces inside
+`http.ResponseWriter` is a problematic design choice, but it probably goes as
+deep as the Go language specification itself. But that's okay, I still prefer
+Go over the alternatives ;).
+
+## Performance
+
+```
+BenchmarkBaseline-8      	   20000	     94912 ns/op
+BenchmarkCaptureMetrics-8	   20000	     95461 ns/op
+```
+
+As you can see, using `CaptureMetrics` on a vanilla http.Handler introduces an
+overhead of ~500 ns per http request on my machine. However, the margin of
+error appears to be larger than that, therefor it should be reasonable to
+assume that the overhead introduced by `CaptureMetrics` is absolutely
+negligible.
+
+## License
+
+MIT

vendor/github.com/felixge/httpsnoop/capture_metrics.go

@@ -0,0 +1,86 @@
+package httpsnoop
+
+import (
+	"io"
+	"net/http"
+	"time"
+)
+
+// Metrics holds metrics captured from CaptureMetrics.
+type Metrics struct {
+	// Code is the first http response code passed to the WriteHeader func of
+	// the ResponseWriter. If no such call is made, a default code of 200 is
+	// assumed instead.
+	Code int
+	// Duration is the time it took to execute the handler.
+	Duration time.Duration
+	// Written is the number of bytes successfully written by the Write or
+	// ReadFrom function of the ResponseWriter. ResponseWriters may also write
+	// data to their underlaying connection directly (e.g. headers), but those
+	// are not tracked. Therefor the number of Written bytes will usually match
+	// the size of the response body.
+	Written int64
+}
+
+// CaptureMetrics wraps the given hnd, executes it with the given w and r, and
+// returns the metrics it captured from it.
+func CaptureMetrics(hnd http.Handler, w http.ResponseWriter, r *http.Request) Metrics {
+	return CaptureMetricsFn(w, func(ww http.ResponseWriter) {
+		hnd.ServeHTTP(ww, r)
+	})
+}
+
+// CaptureMetricsFn wraps w and calls fn with the wrapped w and returns the
+// resulting metrics. This is very similar to CaptureMetrics (which is just
+// sugar on top of this func), but is a more usable interface if your
+// application doesn't use the Go http.Handler interface.
+func CaptureMetricsFn(w http.ResponseWriter, fn func(http.ResponseWriter)) Metrics {
+	m := Metrics{Code: http.StatusOK}
+	m.CaptureMetrics(w, fn)
+	return m
+}
+
+// CaptureMetrics wraps w and calls fn with the wrapped w and updates
+// Metrics m with the resulting metrics. This is similar to CaptureMetricsFn,
+// but allows one to customize starting Metrics object.
+func (m *Metrics) CaptureMetrics(w http.ResponseWriter, fn func(http.ResponseWriter)) {
+	var (
+		start         = time.Now()
+		headerWritten bool
+		hooks         = Hooks{
+			WriteHeader: func(next WriteHeaderFunc) WriteHeaderFunc {
+				return func(code int) {
+					next(code)
+
+					if !headerWritten {
+						m.Code = code
+						headerWritten = true
+					}
+				}
+			},
+
+			Write: func(next WriteFunc) WriteFunc {
+				return func(p []byte) (int, error) {
+					n, err := next(p)
+
+					m.Written += int64(n)
+					headerWritten = true
+					return n, err
+				}
+			},
+
+			ReadFrom: func(next ReadFromFunc) ReadFromFunc {
+				return func(src io.Reader) (int64, error) {
+					n, err := next(src)
+
+					headerWritten = true
+					m.Written += n
+					return n, err
+				}
+			},
+		}
+	)
+
+	fn(Wrap(w, hooks))
+	m.Duration += time.Since(start)
+}

vendor/github.com/felixge/httpsnoop/docs.go

@@ -0,0 +1,10 @@
+// Package httpsnoop provides an easy way to capture http related metrics (i.e.
+// response time, bytes written, and http status code) from your application's
+// http.Handlers.
+//
+// Doing this requires non-trivial wrapping of the http.ResponseWriter
+// interface, which is also exposed for users interested in a more low-level
+// API.
+package httpsnoop
+
+//go:generate go run codegen/main.go

vendor/github.com/felixge/httpsnoop/wrap_generated_gteq_1.8.go

@@ -0,0 +1,436 @@
+// +build go1.8
+// Code generated by "httpsnoop/codegen"; DO NOT EDIT
+
+package httpsnoop
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+)
+
+// HeaderFunc is part of the http.ResponseWriter interface.
+type HeaderFunc func() http.Header
+
+// WriteHeaderFunc is part of the http.ResponseWriter interface.
+type WriteHeaderFunc func(code int)
+
+// WriteFunc is part of the http.ResponseWriter interface.
+type WriteFunc func(b []byte) (int, error)
+
+// FlushFunc is part of the http.Flusher interface.
+type FlushFunc func()
+
+// CloseNotifyFunc is part of the http.CloseNotifier interface.
+type CloseNotifyFunc func() <-chan bool
+
+// HijackFunc is part of the http.Hijacker interface.
+type HijackFunc func() (net.Conn, *bufio.ReadWriter, error)
+
+// ReadFromFunc is part of the io.ReaderFrom interface.
+type ReadFromFunc func(src io.Reader) (int64, error)
+
+// PushFunc is part of the http.Pusher interface.
+type PushFunc func(target string, opts *http.PushOptions) error
+
+// Hooks defines a set of method interceptors for methods included in
+// http.ResponseWriter as well as some others. You can think of them as
+// middleware for the function calls they target. See Wrap for more details.
+type Hooks struct {
+	Header      func(HeaderFunc) HeaderFunc
+	WriteHeader func(WriteHeaderFunc) WriteHeaderFunc
+	Write       func(WriteFunc) WriteFunc
+	Flush       func(FlushFunc) FlushFunc
+	CloseNotify func(CloseNotifyFunc) CloseNotifyFunc
+	Hijack      func(HijackFunc) HijackFunc
+	ReadFrom    func(ReadFromFunc) ReadFromFunc
+	Push        func(PushFunc) PushFunc
+}
+
+// Wrap returns a wrapped version of w that provides the exact same interface
+// as w. Specifically if w implements any combination of:
+//
+// - http.Flusher
+// - http.CloseNotifier
+// - http.Hijacker
+// - io.ReaderFrom
+// - http.Pusher
+//
+// The wrapped version will implement the exact same combination. If no hooks
+// are set, the wrapped version also behaves exactly as w. Hooks targeting
+// methods not supported by w are ignored. Any other hooks will intercept the
+// method they target and may modify the call's arguments and/or return values.
+// The CaptureMetrics implementation serves as a working example for how the
+// hooks can be used.
+func Wrap(w http.ResponseWriter, hooks Hooks) http.ResponseWriter {
+	rw := &rw{w: w, h: hooks}
+	_, i0 := w.(http.Flusher)
+	_, i1 := w.(http.CloseNotifier)
+	_, i2 := w.(http.Hijacker)
+	_, i3 := w.(io.ReaderFrom)
+	_, i4 := w.(http.Pusher)
+	switch {
+	// combination 1/32
+	case !i0 && !i1 && !i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+		}{rw, rw}
+	// combination 2/32
+	case !i0 && !i1 && !i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Pusher
+		}{rw, rw, rw}
+	// combination 3/32
+	case !i0 && !i1 && !i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			io.ReaderFrom
+		}{rw, rw, rw}
+	// combination 4/32
+	case !i0 && !i1 && !i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw}
+	// combination 5/32
+	case !i0 && !i1 && i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Hijacker
+		}{rw, rw, rw}
+	// combination 6/32
+	case !i0 && !i1 && i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Hijacker
+			http.Pusher
+		}{rw, rw, rw, rw}
+	// combination 7/32
+	case !i0 && !i1 && i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw}
+	// combination 8/32
+	case !i0 && !i1 && i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Hijacker
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw}
+	// combination 9/32
+	case !i0 && i1 && !i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+		}{rw, rw, rw}
+	// combination 10/32
+	case !i0 && i1 && !i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Pusher
+		}{rw, rw, rw, rw}
+	// combination 11/32
+	case !i0 && i1 && !i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			io.ReaderFrom
+		}{rw, rw, rw, rw}
+	// combination 12/32
+	case !i0 && i1 && !i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw}
+	// combination 13/32
+	case !i0 && i1 && i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Hijacker
+		}{rw, rw, rw, rw}
+	// combination 14/32
+	case !i0 && i1 && i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Hijacker
+			http.Pusher
+		}{rw, rw, rw, rw, rw}
+	// combination 15/32
+	case !i0 && i1 && i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw}
+	// combination 16/32
+	case !i0 && i1 && i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Hijacker
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw, rw}
+	// combination 17/32
+	case i0 && !i1 && !i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+		}{rw, rw, rw}
+	// combination 18/32
+	case i0 && !i1 && !i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Pusher
+		}{rw, rw, rw, rw}
+	// combination 19/32
+	case i0 && !i1 && !i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			io.ReaderFrom
+		}{rw, rw, rw, rw}
+	// combination 20/32
+	case i0 && !i1 && !i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw}
+	// combination 21/32
+	case i0 && !i1 && i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Hijacker
+		}{rw, rw, rw, rw}
+	// combination 22/32
+	case i0 && !i1 && i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Hijacker
+			http.Pusher
+		}{rw, rw, rw, rw, rw}
+	// combination 23/32
+	case i0 && !i1 && i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw}
+	// combination 24/32
+	case i0 && !i1 && i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Hijacker
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw, rw}
+	// combination 25/32
+	case i0 && i1 && !i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+		}{rw, rw, rw, rw}
+	// combination 26/32
+	case i0 && i1 && !i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Pusher
+		}{rw, rw, rw, rw, rw}
+	// combination 27/32
+	case i0 && i1 && !i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw}
+	// combination 28/32
+	case i0 && i1 && !i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw, rw}
+	// combination 29/32
+	case i0 && i1 && i2 && !i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Hijacker
+		}{rw, rw, rw, rw, rw}
+	// combination 30/32
+	case i0 && i1 && i2 && !i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Hijacker
+			http.Pusher
+		}{rw, rw, rw, rw, rw, rw}
+	// combination 31/32
+	case i0 && i1 && i2 && i3 && !i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw, rw}
+	// combination 32/32
+	case i0 && i1 && i2 && i3 && i4:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Hijacker
+			io.ReaderFrom
+			http.Pusher
+		}{rw, rw, rw, rw, rw, rw, rw}
+	}
+	panic("unreachable")
+}
+
+type rw struct {
+	w http.ResponseWriter
+	h Hooks
+}
+
+func (w *rw) Unwrap() http.ResponseWriter {
+	return w.w
+}
+
+func (w *rw) Header() http.Header {
+	f := w.w.(http.ResponseWriter).Header
+	if w.h.Header != nil {
+		f = w.h.Header(f)
+	}
+	return f()
+}
+
+func (w *rw) WriteHeader(code int) {
+	f := w.w.(http.ResponseWriter).WriteHeader
+	if w.h.WriteHeader != nil {
+		f = w.h.WriteHeader(f)
+	}
+	f(code)
+}
+
+func (w *rw) Write(b []byte) (int, error) {
+	f := w.w.(http.ResponseWriter).Write
+	if w.h.Write != nil {
+		f = w.h.Write(f)
+	}
+	return f(b)
+}
+
+func (w *rw) Flush() {
+	f := w.w.(http.Flusher).Flush
+	if w.h.Flush != nil {
+		f = w.h.Flush(f)
+	}
+	f()
+}
+
+func (w *rw) CloseNotify() <-chan bool {
+	f := w.w.(http.CloseNotifier).CloseNotify
+	if w.h.CloseNotify != nil {
+		f = w.h.CloseNotify(f)
+	}
+	return f()
+}
+
+func (w *rw) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	f := w.w.(http.Hijacker).Hijack
+	if w.h.Hijack != nil {
+		f = w.h.Hijack(f)
+	}
+	return f()
+}
+
+func (w *rw) ReadFrom(src io.Reader) (int64, error) {
+	f := w.w.(io.ReaderFrom).ReadFrom
+	if w.h.ReadFrom != nil {
+		f = w.h.ReadFrom(f)
+	}
+	return f(src)
+}
+
+func (w *rw) Push(target string, opts *http.PushOptions) error {
+	f := w.w.(http.Pusher).Push
+	if w.h.Push != nil {
+		f = w.h.Push(f)
+	}
+	return f(target, opts)
+}
+
+type Unwrapper interface {
+	Unwrap() http.ResponseWriter
+}
+
+// Unwrap returns the underlying http.ResponseWriter from within zero or more
+// layers of httpsnoop wrappers.
+func Unwrap(w http.ResponseWriter) http.ResponseWriter {
+	if rw, ok := w.(Unwrapper); ok {
+		// recurse until rw.Unwrap() returns a non-Unwrapper
+		return Unwrap(rw.Unwrap())
+	} else {
+		return w
+	}
+}

vendor/github.com/felixge/httpsnoop/wrap_generated_lt_1.8.go

@@ -0,0 +1,278 @@
+// +build !go1.8
+// Code generated by "httpsnoop/codegen"; DO NOT EDIT
+
+package httpsnoop
+
+import (
+	"bufio"
+	"io"
+	"net"
+	"net/http"
+)
+
+// HeaderFunc is part of the http.ResponseWriter interface.
+type HeaderFunc func() http.Header
+
+// WriteHeaderFunc is part of the http.ResponseWriter interface.
+type WriteHeaderFunc func(code int)
+
+// WriteFunc is part of the http.ResponseWriter interface.
+type WriteFunc func(b []byte) (int, error)
+
+// FlushFunc is part of the http.Flusher interface.
+type FlushFunc func()
+
+// CloseNotifyFunc is part of the http.CloseNotifier interface.
+type CloseNotifyFunc func() <-chan bool
+
+// HijackFunc is part of the http.Hijacker interface.
+type HijackFunc func() (net.Conn, *bufio.ReadWriter, error)
+
+// ReadFromFunc is part of the io.ReaderFrom interface.
+type ReadFromFunc func(src io.Reader) (int64, error)
+
+// Hooks defines a set of method interceptors for methods included in
+// http.ResponseWriter as well as some others. You can think of them as
+// middleware for the function calls they target. See Wrap for more details.
+type Hooks struct {
+	Header      func(HeaderFunc) HeaderFunc
+	WriteHeader func(WriteHeaderFunc) WriteHeaderFunc
+	Write       func(WriteFunc) WriteFunc
+	Flush       func(FlushFunc) FlushFunc
+	CloseNotify func(CloseNotifyFunc) CloseNotifyFunc
+	Hijack      func(HijackFunc) HijackFunc
+	ReadFrom    func(ReadFromFunc) ReadFromFunc
+}
+
+// Wrap returns a wrapped version of w that provides the exact same interface
+// as w. Specifically if w implements any combination of:
+//
+// - http.Flusher
+// - http.CloseNotifier
+// - http.Hijacker
+// - io.ReaderFrom
+//
+// The wrapped version will implement the exact same combination. If no hooks
+// are set, the wrapped version also behaves exactly as w. Hooks targeting
+// methods not supported by w are ignored. Any other hooks will intercept the
+// method they target and may modify the call's arguments and/or return values.
+// The CaptureMetrics implementation serves as a working example for how the
+// hooks can be used.
+func Wrap(w http.ResponseWriter, hooks Hooks) http.ResponseWriter {
+	rw := &rw{w: w, h: hooks}
+	_, i0 := w.(http.Flusher)
+	_, i1 := w.(http.CloseNotifier)
+	_, i2 := w.(http.Hijacker)
+	_, i3 := w.(io.ReaderFrom)
+	switch {
+	// combination 1/16
+	case !i0 && !i1 && !i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+		}{rw, rw}
+	// combination 2/16
+	case !i0 && !i1 && !i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			io.ReaderFrom
+		}{rw, rw, rw}
+	// combination 3/16
+	case !i0 && !i1 && i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Hijacker
+		}{rw, rw, rw}
+	// combination 4/16
+	case !i0 && !i1 && i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw}
+	// combination 5/16
+	case !i0 && i1 && !i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+		}{rw, rw, rw}
+	// combination 6/16
+	case !i0 && i1 && !i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			io.ReaderFrom
+		}{rw, rw, rw, rw}
+	// combination 7/16
+	case !i0 && i1 && i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Hijacker
+		}{rw, rw, rw, rw}
+	// combination 8/16
+	case !i0 && i1 && i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.CloseNotifier
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw}
+	// combination 9/16
+	case i0 && !i1 && !i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+		}{rw, rw, rw}
+	// combination 10/16
+	case i0 && !i1 && !i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			io.ReaderFrom
+		}{rw, rw, rw, rw}
+	// combination 11/16
+	case i0 && !i1 && i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Hijacker
+		}{rw, rw, rw, rw}
+	// combination 12/16
+	case i0 && !i1 && i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw}
+	// combination 13/16
+	case i0 && i1 && !i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+		}{rw, rw, rw, rw}
+	// combination 14/16
+	case i0 && i1 && !i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw}
+	// combination 15/16
+	case i0 && i1 && i2 && !i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Hijacker
+		}{rw, rw, rw, rw, rw}
+	// combination 16/16
+	case i0 && i1 && i2 && i3:
+		return struct {
+			Unwrapper
+			http.ResponseWriter
+			http.Flusher
+			http.CloseNotifier
+			http.Hijacker
+			io.ReaderFrom
+		}{rw, rw, rw, rw, rw, rw}
+	}
+	panic("unreachable")
+}
+
+type rw struct {
+	w http.ResponseWriter
+	h Hooks
+}
+
+func (w *rw) Unwrap() http.ResponseWriter {
+	return w.w
+}
+
+func (w *rw) Header() http.Header {
+	f := w.w.(http.ResponseWriter).Header
+	if w.h.Header != nil {
+		f = w.h.Header(f)
+	}
+	return f()
+}
+
+func (w *rw) WriteHeader(code int) {
+	f := w.w.(http.ResponseWriter).WriteHeader
+	if w.h.WriteHeader != nil {
+		f = w.h.WriteHeader(f)
+	}
+	f(code)
+}
+
+func (w *rw) Write(b []byte) (int, error) {
+	f := w.w.(http.ResponseWriter).Write
+	if w.h.Write != nil {
+		f = w.h.Write(f)
+	}
+	return f(b)
+}
+
+func (w *rw) Flush() {
+	f := w.w.(http.Flusher).Flush
+	if w.h.Flush != nil {
+		f = w.h.Flush(f)
+	}
+	f()
+}
+
+func (w *rw) CloseNotify() <-chan bool {
+	f := w.w.(http.CloseNotifier).CloseNotify
+	if w.h.CloseNotify != nil {
+		f = w.h.CloseNotify(f)
+	}
+	return f()
+}
+
+func (w *rw) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	f := w.w.(http.Hijacker).Hijack
+	if w.h.Hijack != nil {
+		f = w.h.Hijack(f)
+	}
+	return f()
+}
+
+func (w *rw) ReadFrom(src io.Reader) (int64, error) {
+	f := w.w.(io.ReaderFrom).ReadFrom
+	if w.h.ReadFrom != nil {
+		f = w.h.ReadFrom(f)
+	}
+	return f(src)
+}
+
+type Unwrapper interface {
+	Unwrap() http.ResponseWriter
+}
+
+// Unwrap returns the underlying http.ResponseWriter from within zero or more
+// layers of httpsnoop wrappers.
+func Unwrap(w http.ResponseWriter) http.ResponseWriter {
+	if rw, ok := w.(Unwrapper); ok {
+		// recurse until rw.Unwrap() returns a non-Unwrapper
+		return Unwrap(rw.Unwrap())
+	} else {
+		return w
+	}
+}

vendor/github.com/go-kit/kit/sd/doc.go

@@ -1,6 +0,0 @@
-// Package sd provides utilities related to service discovery. That includes the
-// client-side loadbalancer pattern, where a microservice subscribes to a
-// service discovery system in order to reach remote instances; as well as the
-// registrator pattern, where a microservice registers itself in a service
-// discovery system. Implementations are provided for most common systems.
-package sd

vendor/github.com/go-kit/kit/sd/endpoint_cache.go

@@ -1,143 +0,0 @@
-package sd
-
-import (
-	"io"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/go-kit/log"
-)
-
-// endpointCache collects the most recent set of instances from a service discovery
-// system, creates endpoints for them using a factory function, and makes
-// them available to consumers.
-type endpointCache struct {
-	options            endpointerOptions
-	mtx                sync.RWMutex
-	factory            Factory
-	cache              map[string]endpointCloser
-	err                error
-	endpoints          []endpoint.Endpoint
-	logger             log.Logger
-	invalidateDeadline time.Time
-	timeNow            func() time.Time
-}
-
-type endpointCloser struct {
-	endpoint.Endpoint
-	io.Closer
-}
-
-// newEndpointCache returns a new, empty endpointCache.
-func newEndpointCache(factory Factory, logger log.Logger, options endpointerOptions) *endpointCache {
-	return &endpointCache{
-		options: options,
-		factory: factory,
-		cache:   map[string]endpointCloser{},
-		logger:  logger,
-		timeNow: time.Now,
-	}
-}
-
-// Update should be invoked by clients with a complete set of current instance
-// strings whenever that set changes. The cache manufactures new endpoints via
-// the factory, closes old endpoints when they disappear, and persists existing
-// endpoints if they survive through an update.
-func (c *endpointCache) Update(event Event) {
-	c.mtx.Lock()
-	defer c.mtx.Unlock()
-
-	// Happy path.
-	if event.Err == nil {
-		c.updateCache(event.Instances)
-		c.err = nil
-		return
-	}
-
-	// Sad path. Something's gone wrong in sd.
-	c.logger.Log("err", event.Err)
-	if !c.options.invalidateOnError {
-		return // keep returning the last known endpoints on error
-	}
-	if c.err != nil {
-		return // already in the error state, do nothing & keep original error
-	}
-	c.err = event.Err
-	// set new deadline to invalidate Endpoints unless non-error Event is received
-	c.invalidateDeadline = c.timeNow().Add(c.options.invalidateTimeout)
-	return
-}
-
-func (c *endpointCache) updateCache(instances []string) {
-	// Deterministic order (for later).
-	sort.Strings(instances)
-
-	// Produce the current set of services.
-	cache := make(map[string]endpointCloser, len(instances))
-	for _, instance := range instances {
-		// If it already exists, just copy it over.
-		if sc, ok := c.cache[instance]; ok {
-			cache[instance] = sc
-			delete(c.cache, instance)
-			continue
-		}
-
-		// If it doesn't exist, create it.
-		service, closer, err := c.factory(instance)
-		if err != nil {
-			c.logger.Log("instance", instance, "err", err)
-			continue
-		}
-		cache[instance] = endpointCloser{service, closer}
-	}
-
-	// Close any leftover endpoints.
-	for _, sc := range c.cache {
-		if sc.Closer != nil {
-			sc.Closer.Close()
-		}
-	}
-
-	// Populate the slice of endpoints.
-	endpoints := make([]endpoint.Endpoint, 0, len(cache))
-	for _, instance := range instances {
-		// A bad factory may mean an instance is not present.
-		if _, ok := cache[instance]; !ok {
-			continue
-		}
-		endpoints = append(endpoints, cache[instance].Endpoint)
-	}
-
-	// Swap and trigger GC for old copies.
-	c.endpoints = endpoints
-	c.cache = cache
-}
-
-// Endpoints yields the current set of (presumably identical) endpoints, ordered
-// lexicographically by the corresponding instance string.
-func (c *endpointCache) Endpoints() ([]endpoint.Endpoint, error) {
-	// in the steady state we're going to have many goroutines calling Endpoints()
-	// concurrently, so to minimize contention we use a shared R-lock.
-	c.mtx.RLock()
-
-	if c.err == nil || c.timeNow().Before(c.invalidateDeadline) {
-		defer c.mtx.RUnlock()
-		return c.endpoints, nil
-	}
-
-	c.mtx.RUnlock()
-
-	// in case of an error, switch to an exclusive lock.
-	c.mtx.Lock()
-	defer c.mtx.Unlock()
-
-	// re-check condition due to a race between RUnlock() and Lock().
-	if c.err == nil || c.timeNow().Before(c.invalidateDeadline) {
-		return c.endpoints, nil
-	}
-
-	c.updateCache(nil) // close any remaining active endpoints
-	return nil, c.err
-}

vendor/github.com/go-kit/kit/sd/endpointer.go

@@ -1,90 +0,0 @@
-package sd
-
-import (
-	"time"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/go-kit/log"
-)
-
-// Endpointer listens to a service discovery system and yields a set of
-// identical endpoints on demand. An error indicates a problem with connectivity
-// to the service discovery system, or within the system itself; an Endpointer
-// may yield no endpoints without error.
-type Endpointer interface {
-	Endpoints() ([]endpoint.Endpoint, error)
-}
-
-// FixedEndpointer yields a fixed set of endpoints.
-type FixedEndpointer []endpoint.Endpoint
-
-// Endpoints implements Endpointer.
-func (s FixedEndpointer) Endpoints() ([]endpoint.Endpoint, error) { return s, nil }
-
-// NewEndpointer creates an Endpointer that subscribes to updates from Instancer src
-// and uses factory f to create Endpoints. If src notifies of an error, the Endpointer
-// keeps returning previously created Endpoints assuming they are still good, unless
-// this behavior is disabled via InvalidateOnError option.
-func NewEndpointer(src Instancer, f Factory, logger log.Logger, options ...EndpointerOption) *DefaultEndpointer {
-	opts := endpointerOptions{}
-	for _, opt := range options {
-		opt(&opts)
-	}
-	se := &DefaultEndpointer{
-		cache:     newEndpointCache(f, logger, opts),
-		instancer: src,
-		ch:        make(chan Event),
-	}
-	go se.receive()
-	src.Register(se.ch)
-	return se
-}
-
-// EndpointerOption allows control of endpointCache behavior.
-type EndpointerOption func(*endpointerOptions)
-
-// InvalidateOnError returns EndpointerOption that controls how the Endpointer
-// behaves when then Instancer publishes an Event containing an error.
-// Without this option the Endpointer continues returning the last known
-// endpoints. With this option, the Endpointer continues returning the last
-// known endpoints until the timeout elapses, then closes all active endpoints
-// and starts returning an error. Once the Instancer sends a new update with
-// valid resource instances, the normal operation is resumed.
-func InvalidateOnError(timeout time.Duration) EndpointerOption {
-	return func(opts *endpointerOptions) {
-		opts.invalidateOnError = true
-		opts.invalidateTimeout = timeout
-	}
-}
-
-type endpointerOptions struct {
-	invalidateOnError bool
-	invalidateTimeout time.Duration
-}
-
-// DefaultEndpointer implements an Endpointer interface.
-// When created with NewEndpointer function, it automatically registers
-// as a subscriber to events from the Instances and maintains a list
-// of active Endpoints.
-type DefaultEndpointer struct {
-	cache     *endpointCache
-	instancer Instancer
-	ch        chan Event
-}
-
-func (de *DefaultEndpointer) receive() {
-	for event := range de.ch {
-		de.cache.Update(event)
-	}
-}
-
-// Close deregisters DefaultEndpointer from the Instancer and stops the internal go-routine.
-func (de *DefaultEndpointer) Close() {
-	de.instancer.Deregister(de.ch)
-	close(de.ch)
-}
-
-// Endpoints implements Endpointer.
-func (de *DefaultEndpointer) Endpoints() ([]endpoint.Endpoint, error) {
-	return de.cache.Endpoints()
-}

vendor/github.com/go-kit/kit/sd/factory.go

@@ -1,17 +0,0 @@
-package sd
-
-import (
-	"io"
-
-	"github.com/go-kit/kit/endpoint"
-)
-
-// Factory is a function that converts an instance string (e.g. host:port) to a
-// specific endpoint. Instances that provide multiple endpoints require multiple
-// factories. A factory also returns an io.Closer that's invoked when the
-// instance goes away and needs to be cleaned up. Factories may return nil
-// closers.
-//
-// Users are expected to provide their own factory functions that assume
-// specific transports, or can deduce transports by parsing the instance string.
-type Factory func(instance string) (endpoint.Endpoint, io.Closer, error)

vendor/github.com/go-kit/kit/sd/instancer.go

@@ -1,38 +0,0 @@
-package sd
-
-// Event represents a push notification generated from the underlying service discovery
-// implementation. It contains either a full set of available resource instances, or
-// an error indicating some issue with obtaining information from discovery backend.
-// Examples of errors may include loosing connection to the discovery backend, or
-// trying to look up resource instances using an incorrectly formatted key.
-// After receiving an Event with an error the listenter should treat previously discovered
-// resource instances as stale (although it may choose to continue using them).
-// If the Instancer is able to restore connection to the discovery backend it must push
-// another Event with the current set of resource instances.
-type Event struct {
-	Instances []string
-	Err       error
-}
-
-// Instancer listens to a service discovery system and notifies registered
-// observers of changes in the resource instances. Every event sent to the channels
-// contains a complete set of instances known to the Instancer. That complete set is
-// sent immediately upon registering the channel, and on any future updates from
-// discovery system.
-type Instancer interface {
-	Register(chan<- Event)
-	Deregister(chan<- Event)
-	Stop()
-}
-
-// FixedInstancer yields a fixed set of instances.
-type FixedInstancer []string
-
-// Register implements Instancer.
-func (d FixedInstancer) Register(ch chan<- Event) { ch <- Event{Instances: d} }
-
-// Deregister implements Instancer.
-func (d FixedInstancer) Deregister(ch chan<- Event) {}
-
-// Stop implements Instancer.
-func (d FixedInstancer) Stop() {}

vendor/github.com/go-kit/kit/sd/lb/balancer.go

@@ -1,15 +0,0 @@
-package lb
-
-import (
-	"errors"
-
-	"github.com/go-kit/kit/endpoint"
-)
-
-// Balancer yields endpoints according to some heuristic.
-type Balancer interface {
-	Endpoint() (endpoint.Endpoint, error)
-}
-
-// ErrNoEndpoints is returned when no qualifying endpoints are available.
-var ErrNoEndpoints = errors.New("no endpoints available")

vendor/github.com/go-kit/kit/sd/lb/doc.go

@@ -1,4 +0,0 @@
-// Package lb implements the client-side load balancer pattern. When combined
-// with a service discovery system of record, it enables a more decentralized
-// architecture, removing the need for separate load balancers like HAProxy.
-package lb

vendor/github.com/go-kit/kit/sd/lb/random.go

@@ -1,32 +0,0 @@
-package lb
-
-import (
-	"math/rand"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/go-kit/kit/sd"
-)
-
-// NewRandom returns a load balancer that selects services randomly.
-func NewRandom(s sd.Endpointer, seed int64) Balancer {
-	return &random{
-		s: s,
-		r: rand.New(rand.NewSource(seed)),
-	}
-}
-
-type random struct {
-	s sd.Endpointer
-	r *rand.Rand
-}
-
-func (r *random) Endpoint() (endpoint.Endpoint, error) {
-	endpoints, err := r.s.Endpoints()
-	if err != nil {
-		return nil, err
-	}
-	if len(endpoints) <= 0 {
-		return nil, ErrNoEndpoints
-	}
-	return endpoints[r.r.Intn(len(endpoints))], nil
-}

vendor/github.com/go-kit/kit/sd/lb/retry.go

@@ -1,117 +0,0 @@
-package lb
-
-import (
-	"context"
-	"fmt"
-	"strings"
-	"time"
-
-	"github.com/go-kit/kit/endpoint"
-)
-
-// RetryError is an error wrapper that is used by the retry mechanism. All
-// errors returned by the retry mechanism via its endpoint will be RetryErrors.
-type RetryError struct {
-	RawErrors []error // all errors encountered from endpoints directly
-	Final     error   // the final, terminating error
-}
-
-func (e RetryError) Error() string {
-	var suffix string
-	if len(e.RawErrors) > 1 {
-		a := make([]string, len(e.RawErrors)-1)
-		for i := 0; i < len(e.RawErrors)-1; i++ { // last one is Final
-			a[i] = e.RawErrors[i].Error()
-		}
-		suffix = fmt.Sprintf(" (previously: %s)", strings.Join(a, "; "))
-	}
-	return fmt.Sprintf("%v%s", e.Final, suffix)
-}
-
-// Callback is a function that is given the current attempt count and the error
-// received from the underlying endpoint. It should return whether the Retry
-// function should continue trying to get a working endpoint, and a custom error
-// if desired. The error message may be nil, but a true/false is always
-// expected. In all cases, if the replacement error is supplied, the received
-// error will be replaced in the calling context.
-type Callback func(n int, received error) (keepTrying bool, replacement error)
-
-// Retry wraps a service load balancer and returns an endpoint oriented load
-// balancer for the specified service method. Requests to the endpoint will be
-// automatically load balanced via the load balancer. Requests that return
-// errors will be retried until they succeed, up to max times, or until the
-// timeout is elapsed, whichever comes first.
-func Retry(max int, timeout time.Duration, b Balancer) endpoint.Endpoint {
-	return RetryWithCallback(timeout, b, maxRetries(max))
-}
-
-func maxRetries(max int) Callback {
-	return func(n int, err error) (keepTrying bool, replacement error) {
-		return n < max, nil
-	}
-}
-
-func alwaysRetry(int, error) (keepTrying bool, replacement error) {
-	return true, nil
-}
-
-// RetryWithCallback wraps a service load balancer and returns an endpoint
-// oriented load balancer for the specified service method. Requests to the
-// endpoint will be automatically load balanced via the load balancer. Requests
-// that return errors will be retried until they succeed, up to max times, until
-// the callback returns false, or until the timeout is elapsed, whichever comes
-// first.
-func RetryWithCallback(timeout time.Duration, b Balancer, cb Callback) endpoint.Endpoint {
-	if cb == nil {
-		cb = alwaysRetry
-	}
-	if b == nil {
-		panic("nil Balancer")
-	}
-
-	return func(ctx context.Context, request interface{}) (response interface{}, err error) {
-		var (
-			newctx, cancel = context.WithTimeout(ctx, timeout)
-			responses      = make(chan interface{}, 1)
-			errs           = make(chan error, 1)
-			final          RetryError
-		)
-		defer cancel()
-
-		for i := 1; ; i++ {
-			go func() {
-				e, err := b.Endpoint()
-				if err != nil {
-					errs <- err
-					return
-				}
-				response, err := e(newctx, request)
-				if err != nil {
-					errs <- err
-					return
-				}
-				responses <- response
-			}()
-
-			select {
-			case <-newctx.Done():
-				return nil, newctx.Err()
-
-			case response := <-responses:
-				return response, nil
-
-			case err := <-errs:
-				final.RawErrors = append(final.RawErrors, err)
-				keepTrying, replacement := cb(i, err)
-				if replacement != nil {
-					err = replacement
-				}
-				if !keepTrying {
-					final.Final = err
-					return nil, final
-				}
-				continue
-			}
-		}
-	}
-}

vendor/github.com/go-kit/kit/sd/lb/round_robin.go

@@ -1,34 +0,0 @@
-package lb
-
-import (
-	"sync/atomic"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/go-kit/kit/sd"
-)
-
-// NewRoundRobin returns a load balancer that returns services in sequence.
-func NewRoundRobin(s sd.Endpointer) Balancer {
-	return &roundRobin{
-		s: s,
-		c: 0,
-	}
-}
-
-type roundRobin struct {
-	s sd.Endpointer
-	c uint64
-}
-
-func (rr *roundRobin) Endpoint() (endpoint.Endpoint, error) {
-	endpoints, err := rr.s.Endpoints()
-	if err != nil {
-		return nil, err
-	}
-	if len(endpoints) <= 0 {
-		return nil, ErrNoEndpoints
-	}
-	old := atomic.AddUint64(&rr.c, 1) - 1
-	idx := old % uint64(len(endpoints))
-	return endpoints[idx], nil
-}

vendor/github.com/go-kit/kit/sd/registrar.go

@@ -1,13 +0,0 @@
-package sd
-
-// Registrar registers instance information to a service discovery system when
-// an instance becomes alive and healthy, and deregisters that information when
-// the service becomes unhealthy or goes away.
-//
-// Registrar implementations exist for various service discovery systems. Note
-// that identifying instance information (e.g. host:port) must be given via the
-// concrete constructor; this interface merely signals lifecycle changes.
-type Registrar interface {
-	Register()
-	Deregister()
-}

vendor/github.com/go-kit/kit/tracing/opentracing/doc.go

@@ -1,4 +0,0 @@
-// Package opentracing provides Go kit integration to the OpenTracing project.
-// OpenTracing implements a general purpose interface that microservices can
-// program against, and which adapts to all major distributed tracing systems.
-package opentracing

vendor/github.com/go-kit/kit/tracing/opentracing/endpoint.go

@@ -1,124 +0,0 @@
-package opentracing
-
-import (
-	"context"
-	"strconv"
-
-	"github.com/opentracing/opentracing-go"
-	otext "github.com/opentracing/opentracing-go/ext"
-	otlog "github.com/opentracing/opentracing-go/log"
-
-	"github.com/go-kit/kit/endpoint"
-	"github.com/go-kit/kit/sd/lb"
-)
-
-// TraceEndpoint returns a Middleware that wraps the `next` Endpoint in an
-// OpenTracing Span called `operationName`.
-//
-// If `ctx` already has a Span, child span is created from it.
-// If `ctx` doesn't yet have a Span, the new one is created.
-func TraceEndpoint(tracer opentracing.Tracer, operationName string, opts ...EndpointOption) endpoint.Middleware {
-	cfg := &EndpointOptions{
-		Tags: make(opentracing.Tags),
-	}
-
-	for _, opt := range opts {
-		opt(cfg)
-	}
-
-	return func(next endpoint.Endpoint) endpoint.Endpoint {
-		return func(ctx context.Context, request interface{}) (response interface{}, err error) {
-			if cfg.GetOperationName != nil {
-				if newOperationName := cfg.GetOperationName(ctx, operationName); newOperationName != "" {
-					operationName = newOperationName
-				}
-			}
-
-			var span opentracing.Span
-			if parentSpan := opentracing.SpanFromContext(ctx); parentSpan != nil {
-				span = tracer.StartSpan(
-					operationName,
-					opentracing.ChildOf(parentSpan.Context()),
-				)
-			} else {
-				span = tracer.StartSpan(operationName)
-			}
-			defer span.Finish()
-
-			applyTags(span, cfg.Tags)
-			if cfg.GetTags != nil {
-				extraTags := cfg.GetTags(ctx)
-				applyTags(span, extraTags)
-			}
-
-			ctx = opentracing.ContextWithSpan(ctx, span)
-
-			defer func() {
-				if err != nil {
-					if lbErr, ok := err.(lb.RetryError); ok {
-						// handle errors originating from lb.Retry
-						fields := make([]otlog.Field, 0, len(lbErr.RawErrors))
-						for idx, rawErr := range lbErr.RawErrors {
-							fields = append(fields, otlog.String(
-								"gokit.retry.error."+strconv.Itoa(idx+1), rawErr.Error(),
-							))
-						}
-
-						otext.LogError(span, lbErr, fields...)
-
-						return
-					}
-
-					// generic error
-					otext.LogError(span, err)
-
-					return
-				}
-
-				// test for business error
-				if res, ok := response.(endpoint.Failer); ok && res.Failed() != nil {
-					span.LogFields(
-						otlog.String("gokit.business.error", res.Failed().Error()),
-					)
-
-					if cfg.IgnoreBusinessError {
-						return
-					}
-
-					// treating business error as real error in span.
-					otext.LogError(span, res.Failed())
-
-					return
-				}
-			}()
-
-			return next(ctx, request)
-		}
-	}
-}
-
-// TraceServer returns a Middleware that wraps the `next` Endpoint in an
-// OpenTracing Span called `operationName` with server span.kind tag..
-func TraceServer(tracer opentracing.Tracer, operationName string, opts ...EndpointOption) endpoint.Middleware {
-	opts = append(opts, WithTags(map[string]interface{}{
-		otext.SpanKindRPCServer.Key: otext.SpanKindRPCServer.Value,
-	}))
-
-	return TraceEndpoint(tracer, operationName, opts...)
-}
-
-// TraceClient returns a Middleware that wraps the `next` Endpoint in an
-// OpenTracing Span called `operationName` with client span.kind tag.
-func TraceClient(tracer opentracing.Tracer, operationName string, opts ...EndpointOption) endpoint.Middleware {
-	opts = append(opts, WithTags(map[string]interface{}{
-		otext.SpanKindRPCClient.Key: otext.SpanKindRPCClient.Value,
-	}))
-
-	return TraceEndpoint(tracer, operationName, opts...)
-}
-
-func applyTags(span opentracing.Span, tags opentracing.Tags) {
-	for key, value := range tags {
-		span.SetTag(key, value)
-	}
-}

vendor/github.com/go-kit/kit/tracing/opentracing/endpoint_options.go

@@ -1,74 +0,0 @@
-package opentracing
-
-import (
-	"context"
-
-	"github.com/opentracing/opentracing-go"
-)
-
-// EndpointOptions holds the options for tracing an endpoint
-type EndpointOptions struct {
-	// IgnoreBusinessError if set to true will not treat a business error
-	// identified through the endpoint.Failer interface as a span error.
-	IgnoreBusinessError bool
-
-	// GetOperationName is an optional function that can set the span operation name based on the existing one
-	// for the endpoint and information in the context.
-	//
-	// If the function is nil, or the returned name is empty, the existing name for the endpoint is used.
-	GetOperationName func(ctx context.Context, name string) string
-
-	// Tags holds the default tags which will be set on span
-	// creation by our Endpoint middleware.
-	Tags opentracing.Tags
-
-	// GetTags is an optional function that can extract tags
-	// from the context and add them to the span.
-	GetTags func(ctx context.Context) opentracing.Tags
-}
-
-// EndpointOption allows for functional options to endpoint tracing middleware.
-type EndpointOption func(*EndpointOptions)
-
-// WithOptions sets all configuration options at once by use of the EndpointOptions struct.
-func WithOptions(options EndpointOptions) EndpointOption {
-	return func(o *EndpointOptions) {
-		*o = options
-	}
-}
-
-// WithIgnoreBusinessError if set to true will not treat a business error
-// identified through the endpoint.Failer interface as a span error.
-func WithIgnoreBusinessError(ignoreBusinessError bool) EndpointOption {
-	return func(o *EndpointOptions) {
-		o.IgnoreBusinessError = ignoreBusinessError
-	}
-}
-
-// WithOperationNameFunc allows to set function that can set the span operation name based on the existing one
-// for the endpoint and information in the context.
-func WithOperationNameFunc(getOperationName func(ctx context.Context, name string) string) EndpointOption {
-	return func(o *EndpointOptions) {
-		o.GetOperationName = getOperationName
-	}
-}
-
-// WithTags adds default tags for the spans created by the Endpoint tracer.
-func WithTags(tags opentracing.Tags) EndpointOption {
-	return func(o *EndpointOptions) {
-		if o.Tags == nil {
-			o.Tags = make(opentracing.Tags)
-		}
-
-		for key, value := range tags {
-			o.Tags[key] = value
-		}
-	}
-}
-
-// WithTagsFunc set the func to extracts additional tags from the context.
-func WithTagsFunc(getTags func(ctx context.Context) opentracing.Tags) EndpointOption {
-	return func(o *EndpointOptions) {
-		o.GetTags = getTags
-	}
-}

vendor/github.com/go-kit/kit/tracing/opentracing/grpc.go

@@ -1,70 +0,0 @@
-package opentracing
-
-import (
-	"context"
-	"encoding/base64"
-	"strings"
-
-	"github.com/opentracing/opentracing-go"
-	"github.com/opentracing/opentracing-go/ext"
-	"google.golang.org/grpc/metadata"
-
-	"github.com/go-kit/log"
-)
-
-// ContextToGRPC returns a grpc RequestFunc that injects an OpenTracing Span
-// found in `ctx` into the grpc Metadata. If no such Span can be found, the
-// RequestFunc is a noop.
-func ContextToGRPC(tracer opentracing.Tracer, logger log.Logger) func(ctx context.Context, md *metadata.MD) context.Context {
-	return func(ctx context.Context, md *metadata.MD) context.Context {
-		if span := opentracing.SpanFromContext(ctx); span != nil {
-			// There's nothing we can do with an error here.
-			if err := tracer.Inject(span.Context(), opentracing.TextMap, metadataReaderWriter{md}); err != nil {
-				logger.Log("err", err)
-			}
-		}
-		return ctx
-	}
-}
-
-// GRPCToContext returns a grpc RequestFunc that tries to join with an
-// OpenTracing trace found in `req` and starts a new Span called
-// `operationName` accordingly. If no trace could be found in `req`, the Span
-// will be a trace root. The Span is incorporated in the returned Context and
-// can be retrieved with opentracing.SpanFromContext(ctx).
-func GRPCToContext(tracer opentracing.Tracer, operationName string, logger log.Logger) func(ctx context.Context, md metadata.MD) context.Context {
-	return func(ctx context.Context, md metadata.MD) context.Context {
-		var span opentracing.Span
-		wireContext, err := tracer.Extract(opentracing.TextMap, metadataReaderWriter{&md})
-		if err != nil && err != opentracing.ErrSpanContextNotFound {
-			logger.Log("err", err)
-		}
-		span = tracer.StartSpan(operationName, ext.RPCServerOption(wireContext))
-		return opentracing.ContextWithSpan(ctx, span)
-	}
-}
-
-// A type that conforms to opentracing.TextMapReader and
-// opentracing.TextMapWriter.
-type metadataReaderWriter struct {
-	*metadata.MD
-}
-
-func (w metadataReaderWriter) Set(key, val string) {
-	key = strings.ToLower(key)
-	if strings.HasSuffix(key, "-bin") {
-		val = base64.StdEncoding.EncodeToString([]byte(val))
-	}
-	(*w.MD)[key] = append((*w.MD)[key], val)
-}
-
-func (w metadataReaderWriter) ForeachKey(handler func(key, val string) error) error {
-	for k, vals := range *w.MD {
-		for _, v := range vals {
-			if err := handler(k, v); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}

vendor/github.com/go-kit/kit/tracing/opentracing/http.go

@@ -1,71 +0,0 @@
-package opentracing
-
-import (
-	"context"
-	"net"
-	"net/http"
-	"strconv"
-
-	opentracing "github.com/opentracing/opentracing-go"
-	"github.com/opentracing/opentracing-go/ext"
-
-	kithttp "github.com/go-kit/kit/transport/http"
-	"github.com/go-kit/log"
-)
-
-// ContextToHTTP returns an http RequestFunc that injects an OpenTracing Span
-// found in `ctx` into the http headers. If no such Span can be found, the
-// RequestFunc is a noop.
-func ContextToHTTP(tracer opentracing.Tracer, logger log.Logger) kithttp.RequestFunc {
-	return func(ctx context.Context, req *http.Request) context.Context {
-		// Try to find a Span in the Context.
-		if span := opentracing.SpanFromContext(ctx); span != nil {
-			// Add standard OpenTracing tags.
-			ext.HTTPMethod.Set(span, req.Method)
-			ext.HTTPUrl.Set(span, req.URL.String())
-			host, portString, err := net.SplitHostPort(req.URL.Host)
-			if err == nil {
-				ext.PeerHostname.Set(span, host)
-				if port, err := strconv.Atoi(portString); err == nil {
-					ext.PeerPort.Set(span, uint16(port))
-				}
-			} else {
-				ext.PeerHostname.Set(span, req.URL.Host)
-			}
-
-			// There's nothing we can do with any errors here.
-			if err = tracer.Inject(
-				span.Context(),
-				opentracing.HTTPHeaders,
-				opentracing.HTTPHeadersCarrier(req.Header),
-			); err != nil {
-				logger.Log("err", err)
-			}
-		}
-		return ctx
-	}
-}
-
-// HTTPToContext returns an http RequestFunc that tries to join with an
-// OpenTracing trace found in `req` and starts a new Span called
-// `operationName` accordingly. If no trace could be found in `req`, the Span
-// will be a trace root. The Span is incorporated in the returned Context and
-// can be retrieved with opentracing.SpanFromContext(ctx).
-func HTTPToContext(tracer opentracing.Tracer, operationName string, logger log.Logger) kithttp.RequestFunc {
-	return func(ctx context.Context, req *http.Request) context.Context {
-		// Try to join to a trace propagated in `req`.
-		var span opentracing.Span
-		wireContext, err := tracer.Extract(
-			opentracing.HTTPHeaders,
-			opentracing.HTTPHeadersCarrier(req.Header),
-		)
-		if err != nil && err != opentracing.ErrSpanContextNotFound {
-			logger.Log("err", err)
-		}
-
-		span = tracer.StartSpan(operationName, ext.RPCServerOption(wireContext))
-		ext.HTTPMethod.Set(span, req.Method)
-		ext.HTTPUrl.Set(span, req.URL.String())
-		return opentracing.ContextWithSpan(ctx, span)
-	}
-}

vendor/github.com/opentracing/opentracing-go/.gitignore

@@ -1 +0,0 @@
-coverage.txt

vendor/github.com/opentracing/opentracing-go/.travis.yml

@@ -1,20 +0,0 @@
-language: go
-
-matrix:
-  include:
-  - go: "1.13.x"
-  - go: "1.14.x"
-  - go: "tip"
-    env:
-    - LINT=true
-    - COVERAGE=true
-
-install:
-  - if [ "$LINT" == true ]; then go get -u golang.org/x/lint/golint/... ; else echo 'skipping lint'; fi
-  - go get -u github.com/stretchr/testify/...
-
-script:
-  - make test
-  - go build ./...
-  - if [ "$LINT" == true ]; then make lint ; else echo 'skipping lint'; fi
-  - if [ "$COVERAGE" == true ]; then make cover && bash <(curl -s https://codecov.io/bash) ; else echo 'skipping coverage'; fi

vendor/github.com/opentracing/opentracing-go/CHANGELOG.md

@@ -1,63 +0,0 @@
-Changes by Version
-==================
-
-
-1.2.0 (2020-07-01)
--------------------
-
-* Restore the ability to reset the current span in context to nil (#231) -- Yuri Shkuro
-* Use error.object per OpenTracing Semantic Conventions (#179) -- Rahman Syed
-* Convert nil pointer log field value to string "nil" (#230) -- Cyril Tovena
-* Add Go module support (#215) -- Zaba505
-* Make SetTag helper types in ext public (#229) -- Blake Edwards
-* Add log/fields helpers for keys from specification (#226) -- Dmitry Monakhov
-* Improve noop impementation (#223) -- chanxuehong
-* Add an extension to Tracer interface for custom go context creation (#220) -- Krzesimir Nowak
-* Fix typo in comments (#222) -- meteorlxy
-* Improve documentation for log.Object() to emphasize the requirement to pass immutable arguments (#219) -- 疯狂的小企鹅
-* [mock] Return ErrInvalidSpanContext if span context is not MockSpanContext (#216) -- Milad Irannejad
-
-
-1.1.0 (2019-03-23)
--------------------
-
-Notable changes:
-- The library is now released under Apache 2.0 license
-- Use Set() instead of Add() in HTTPHeadersCarrier is functionally a breaking change (fixes issue [#159](https://github.com/opentracing/opentracing-go/issues/159))
-- 'golang.org/x/net/context' is replaced with 'context' from the standard library
-
-List of all changes:
-
-- Export StartSpanFromContextWithTracer (#214) <Aaron Delaney>
-- Add IsGlobalTracerRegistered() to indicate if a tracer has been registered (#201) <Mike Goldsmith>
-- Use Set() instead of Add() in HTTPHeadersCarrier (#191) <jeremyxu2010>
-- Update license to Apache 2.0 (#181) <Andrea Kao>
-- Replace 'golang.org/x/net/context' with 'context' (#176) <Tony Ghita>
-- Port of Python opentracing/harness/api_check.py to Go (#146) <chris erway>
-- Fix race condition in MockSpan.Context() (#170) <Brad>
-- Add PeerHostIPv4.SetString() (#155)  <NeoCN>
-- Add a Noop log field type to log to allow for optional fields (#150)  <Matt Ho>
-
-
-1.0.2 (2017-04-26)
--------------------
-
-- Add more semantic tags (#139) <Rustam Zagirov>
-
-
-1.0.1 (2017-02-06)
--------------------
-
-- Correct spelling in comments <Ben Sigelman>
-- Address race in nextMockID() (#123) <bill fumerola>
-- log: avoid panic marshaling nil error (#131) <Anthony Voutas>
-- Deprecate InitGlobalTracer in favor of SetGlobalTracer (#128) <Yuri Shkuro>
-- Drop Go 1.5 that fails in Travis (#129) <Yuri Shkuro>
-- Add convenience methods Key() and Value() to log.Field <Ben Sigelman>
-- Add convenience methods to log.Field (2 years, 6 months ago) <Radu Berinde>
-
-1.0.0 (2016-09-26)
--------------------
-
-- This release implements OpenTracing Specification 1.0 (https://opentracing.io/spec)
-

vendor/github.com/opentracing/opentracing-go/Makefile

@@ -1,20 +0,0 @@
-.DEFAULT_GOAL := test-and-lint
-
-.PHONY: test-and-lint
-test-and-lint: test lint
-
-.PHONY: test
-test:
-	go test -v -cover -race ./...
-
-.PHONY: cover
-cover:
-	go test -v -coverprofile=coverage.txt -covermode=atomic -race ./...
-
-.PHONY: lint
-lint:
-	go fmt ./...
-	golint ./...
-	@# Run again with magic to exit non-zero if golint outputs anything.
-	@! (golint ./... | read dummy)
-	go vet ./...

vendor/github.com/opentracing/opentracing-go/README.md

@@ -1,171 +0,0 @@
-[![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/opentracing/public) [![Build Status](https://travis-ci.org/opentracing/opentracing-go.svg?branch=master)](https://travis-ci.org/opentracing/opentracing-go) [![GoDoc](https://godoc.org/github.com/opentracing/opentracing-go?status.svg)](http://godoc.org/github.com/opentracing/opentracing-go)
-[![Sourcegraph Badge](https://sourcegraph.com/github.com/opentracing/opentracing-go/-/badge.svg)](https://sourcegraph.com/github.com/opentracing/opentracing-go?badge)
-
-# OpenTracing API for Go
-
-This package is a Go platform API for OpenTracing.
-
-## Required Reading
-
-In order to understand the Go platform API, one must first be familiar with the
-[OpenTracing project](https://opentracing.io) and
-[terminology](https://opentracing.io/specification/) more specifically.
-
-## API overview for those adding instrumentation
-
-Everyday consumers of this `opentracing` package really only need to worry
-about a couple of key abstractions: the `StartSpan` function, the `Span`
-interface, and binding a `Tracer` at `main()`-time. Here are code snippets
-demonstrating some important use cases.
-
-#### Singleton initialization
-
-The simplest starting point is `./default_tracer.go`. As early as possible, call
-
-```go
-    import "github.com/opentracing/opentracing-go"
-    import ".../some_tracing_impl"
-
-    func main() {
-        opentracing.SetGlobalTracer(
-            // tracing impl specific:
-            some_tracing_impl.New(...),
-        )
-        ...
-    }
-```
-
-#### Non-Singleton initialization
-
-If you prefer direct control to singletons, manage ownership of the
-`opentracing.Tracer` implementation explicitly.
-
-#### Creating a Span given an existing Go `context.Context`
-
-If you use `context.Context` in your application, OpenTracing's Go library will
-happily rely on it for `Span` propagation. To start a new (blocking child)
-`Span`, you can use `StartSpanFromContext`.
-
-```go
-    func xyz(ctx context.Context, ...) {
-        ...
-        span, ctx := opentracing.StartSpanFromContext(ctx, "operation_name")
-        defer span.Finish()
-        span.LogFields(
-            log.String("event", "soft error"),
-            log.String("type", "cache timeout"),
-            log.Int("waited.millis", 1500))
-        ...
-    }
-```
-
-#### Starting an empty trace by creating a "root span"
-
-It's always possible to create a "root" `Span` with no parent or other causal
-reference.
-
-```go
-    func xyz() {
-        ...
-        sp := opentracing.StartSpan("operation_name")
-        defer sp.Finish()
-        ...
-    }
-```
-
-#### Creating a (child) Span given an existing (parent) Span
-
-```go
-    func xyz(parentSpan opentracing.Span, ...) {
-        ...
-        sp := opentracing.StartSpan(
-            "operation_name",
-            opentracing.ChildOf(parentSpan.Context()))
-        defer sp.Finish()
-        ...
-    }
-```
-
-#### Serializing to the wire
-
-```go
-    func makeSomeRequest(ctx context.Context) ... {
-        if span := opentracing.SpanFromContext(ctx); span != nil {
-            httpClient := &http.Client{}
-            httpReq, _ := http.NewRequest("GET", "http://myservice/", nil)
-
-            // Transmit the span's TraceContext as HTTP headers on our
-            // outbound request.
-            opentracing.GlobalTracer().Inject(
-                span.Context(),
-                opentracing.HTTPHeaders,
-                opentracing.HTTPHeadersCarrier(httpReq.Header))
-
-            resp, err := httpClient.Do(httpReq)
-            ...
-        }
-        ...
-    }
-```
-
-#### Deserializing from the wire
-
-```go
-    http.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
-        var serverSpan opentracing.Span
-        appSpecificOperationName := ...
-        wireContext, err := opentracing.GlobalTracer().Extract(
-            opentracing.HTTPHeaders,
-            opentracing.HTTPHeadersCarrier(req.Header))
-        if err != nil {
-            // Optionally record something about err here
-        }
-
-        // Create the span referring to the RPC client if available.
-        // If wireContext == nil, a root span will be created.
-        serverSpan = opentracing.StartSpan(
-            appSpecificOperationName,
-            ext.RPCServerOption(wireContext))
-
-        defer serverSpan.Finish()
-
-        ctx := opentracing.ContextWithSpan(context.Background(), serverSpan)
-        ...
-    }
-```
-
-#### Conditionally capture a field using `log.Noop`
-
-In some situations, you may want to dynamically decide whether or not
-to log a field.  For example, you may want to capture additional data,
-such as a customer ID, in non-production environments:
-
-```go
-    func Customer(order *Order) log.Field {
-        if os.Getenv("ENVIRONMENT") == "dev" {
-            return log.String("customer", order.Customer.ID)
-        }
-        return log.Noop()
-    }
-```
-
-#### Goroutine-safety
-
-The entire public API is goroutine-safe and does not require external
-synchronization.
-
-## API pointers for those implementing a tracing system
-
-Tracing system implementors may be able to reuse or copy-paste-modify the `basictracer` package, found [here](https://github.com/opentracing/basictracer-go). In particular, see `basictracer.New(...)`.
-
-## API compatibility
-
-For the time being, "mild" backwards-incompatible changes may be made without changing the major version number. As OpenTracing and `opentracing-go` mature, backwards compatibility will become more of a priority.
-
-## Tracer test suite
-
-A test suite is available in the [harness](https://godoc.org/github.com/opentracing/opentracing-go/harness) package that can assist Tracer implementors to assert that their Tracer is working correctly.
-
-## Licensing
-
-[Apache 2.0 License](./LICENSE).

vendor/github.com/opentracing/opentracing-go/ext.go

@@ -1,24 +0,0 @@
-package opentracing
-
-import (
-	"context"
-)
-
-// TracerContextWithSpanExtension is an extension interface that the
-// implementation of the Tracer interface may want to implement. It
-// allows to have some control over the go context when the
-// ContextWithSpan is invoked.
-//
-// The primary purpose of this extension are adapters from opentracing
-// API to some other tracing API.
-type TracerContextWithSpanExtension interface {
-	// ContextWithSpanHook gets called by the ContextWithSpan
-	// function, when the Tracer implementation also implements
-	// this interface. It allows to put extra information into the
-	// context and make it available to the callers of the
-	// ContextWithSpan.
-	//
-	// This hook is invoked before the ContextWithSpan function
-	// actually puts the span into the context.
-	ContextWithSpanHook(ctx context.Context, span Span) context.Context
-}

vendor/github.com/opentracing/opentracing-go/ext/field.go

@@ -1,17 +0,0 @@
-package ext
-
-import (
-	"github.com/opentracing/opentracing-go"
-	"github.com/opentracing/opentracing-go/log"
-)
-
-// LogError sets the error=true tag on the Span and logs err as an "error" event.
-func LogError(span opentracing.Span, err error, fields ...log.Field) {
-	Error.Set(span, true)
-	ef := []log.Field{
-		log.Event("error"),
-		log.Error(err),
-	}
-	ef = append(ef, fields...)
-	span.LogFields(ef...)
-}

vendor/github.com/opentracing/opentracing-go/ext/tags.go

@@ -1,215 +0,0 @@
-package ext
-
-import "github.com/opentracing/opentracing-go"
-
-// These constants define common tag names recommended for better portability across
-// tracing systems and languages/platforms.
-//
-// The tag names are defined as typed strings, so that in addition to the usual use
-//
-//     span.setTag(TagName, value)
-//
-// they also support value type validation via this additional syntax:
-//
-//    TagName.Set(span, value)
-//
-var (
-	//////////////////////////////////////////////////////////////////////
-	// SpanKind (client/server or producer/consumer)
-	//////////////////////////////////////////////////////////////////////
-
-	// SpanKind hints at relationship between spans, e.g. client/server
-	SpanKind = spanKindTagName("span.kind")
-
-	// SpanKindRPCClient marks a span representing the client-side of an RPC
-	// or other remote call
-	SpanKindRPCClientEnum = SpanKindEnum("client")
-	SpanKindRPCClient     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindRPCClientEnum}
-
-	// SpanKindRPCServer marks a span representing the server-side of an RPC
-	// or other remote call
-	SpanKindRPCServerEnum = SpanKindEnum("server")
-	SpanKindRPCServer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindRPCServerEnum}
-
-	// SpanKindProducer marks a span representing the producer-side of a
-	// message bus
-	SpanKindProducerEnum = SpanKindEnum("producer")
-	SpanKindProducer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindProducerEnum}
-
-	// SpanKindConsumer marks a span representing the consumer-side of a
-	// message bus
-	SpanKindConsumerEnum = SpanKindEnum("consumer")
-	SpanKindConsumer     = opentracing.Tag{Key: string(SpanKind), Value: SpanKindConsumerEnum}
-
-	//////////////////////////////////////////////////////////////////////
-	// Component name
-	//////////////////////////////////////////////////////////////////////
-
-	// Component is a low-cardinality identifier of the module, library,
-	// or package that is generating a span.
-	Component = StringTagName("component")
-
-	//////////////////////////////////////////////////////////////////////
-	// Sampling hint
-	//////////////////////////////////////////////////////////////////////
-
-	// SamplingPriority determines the priority of sampling this Span.
-	SamplingPriority = Uint16TagName("sampling.priority")
-
-	//////////////////////////////////////////////////////////////////////
-	// Peer tags. These tags can be emitted by either client-side or
-	// server-side to describe the other side/service in a peer-to-peer
-	// communications, like an RPC call.
-	//////////////////////////////////////////////////////////////////////
-
-	// PeerService records the service name of the peer.
-	PeerService = StringTagName("peer.service")
-
-	// PeerAddress records the address name of the peer. This may be a "ip:port",
-	// a bare "hostname", a FQDN or even a database DSN substring
-	// like "mysql://username@127.0.0.1:3306/dbname"
-	PeerAddress = StringTagName("peer.address")
-
-	// PeerHostname records the host name of the peer
-	PeerHostname = StringTagName("peer.hostname")
-
-	// PeerHostIPv4 records IP v4 host address of the peer
-	PeerHostIPv4 = IPv4TagName("peer.ipv4")
-
-	// PeerHostIPv6 records IP v6 host address of the peer
-	PeerHostIPv6 = StringTagName("peer.ipv6")
-
-	// PeerPort records port number of the peer
-	PeerPort = Uint16TagName("peer.port")
-
-	//////////////////////////////////////////////////////////////////////
-	// HTTP Tags
-	//////////////////////////////////////////////////////////////////////
-
-	// HTTPUrl should be the URL of the request being handled in this segment
-	// of the trace, in standard URI format. The protocol is optional.
-	HTTPUrl = StringTagName("http.url")
-
-	// HTTPMethod is the HTTP method of the request, and is case-insensitive.
-	HTTPMethod = StringTagName("http.method")
-
-	// HTTPStatusCode is the numeric HTTP status code (200, 404, etc) of the
-	// HTTP response.
-	HTTPStatusCode = Uint16TagName("http.status_code")
-
-	//////////////////////////////////////////////////////////////////////
-	// DB Tags
-	//////////////////////////////////////////////////////////////////////
-
-	// DBInstance is database instance name.
-	DBInstance = StringTagName("db.instance")
-
-	// DBStatement is a database statement for the given database type.
-	// It can be a query or a prepared statement (i.e., before substitution).
-	DBStatement = StringTagName("db.statement")
-
-	// DBType is a database type. For any SQL database, "sql".
-	// For others, the lower-case database category, e.g. "redis"
-	DBType = StringTagName("db.type")
-
-	// DBUser is a username for accessing database.
-	DBUser = StringTagName("db.user")
-
-	//////////////////////////////////////////////////////////////////////
-	// Message Bus Tag
-	//////////////////////////////////////////////////////////////////////
-
-	// MessageBusDestination is an address at which messages can be exchanged
-	MessageBusDestination = StringTagName("message_bus.destination")
-
-	//////////////////////////////////////////////////////////////////////
-	// Error Tag
-	//////////////////////////////////////////////////////////////////////
-
-	// Error indicates that operation represented by the span resulted in an error.
-	Error = BoolTagName("error")
-)
-
-// ---
-
-// SpanKindEnum represents common span types
-type SpanKindEnum string
-
-type spanKindTagName string
-
-// Set adds a string tag to the `span`
-func (tag spanKindTagName) Set(span opentracing.Span, value SpanKindEnum) {
-	span.SetTag(string(tag), value)
-}
-
-type rpcServerOption struct {
-	clientContext opentracing.SpanContext
-}
-
-func (r rpcServerOption) Apply(o *opentracing.StartSpanOptions) {
-	if r.clientContext != nil {
-		opentracing.ChildOf(r.clientContext).Apply(o)
-	}
-	SpanKindRPCServer.Apply(o)
-}
-
-// RPCServerOption returns a StartSpanOption appropriate for an RPC server span
-// with `client` representing the metadata for the remote peer Span if available.
-// In case client == nil, due to the client not being instrumented, this RPC
-// server span will be a root span.
-func RPCServerOption(client opentracing.SpanContext) opentracing.StartSpanOption {
-	return rpcServerOption{client}
-}
-
-// ---
-
-// StringTagName is a common tag name to be set to a string value
-type StringTagName string
-
-// Set adds a string tag to the `span`
-func (tag StringTagName) Set(span opentracing.Span, value string) {
-	span.SetTag(string(tag), value)
-}
-
-// ---
-
-// Uint32TagName is a common tag name to be set to a uint32 value
-type Uint32TagName string
-
-// Set adds a uint32 tag to the `span`
-func (tag Uint32TagName) Set(span opentracing.Span, value uint32) {
-	span.SetTag(string(tag), value)
-}
-
-// ---
-
-// Uint16TagName is a common tag name to be set to a uint16 value
-type Uint16TagName string
-
-// Set adds a uint16 tag to the `span`
-func (tag Uint16TagName) Set(span opentracing.Span, value uint16) {
-	span.SetTag(string(tag), value)
-}
-
-// ---
-
-// BoolTagName is a common tag name to be set to a bool value
-type BoolTagName string
-
-// Set adds a bool tag to the `span`
-func (tag BoolTagName) Set(span opentracing.Span, value bool) {
-	span.SetTag(string(tag), value)
-}
-
-// IPv4TagName is a common tag name to be set to an ipv4 value
-type IPv4TagName string
-
-// Set adds IP v4 host address of the peer as an uint32 value to the `span`, keep this for backward and zipkin compatibility
-func (tag IPv4TagName) Set(span opentracing.Span, value uint32) {
-	span.SetTag(string(tag), value)
-}
-
-// SetString records IP v4 host address of the peer as a .-separated tuple to the `span`. E.g., "127.0.0.1"
-func (tag IPv4TagName) SetString(span opentracing.Span, value string) {
-	span.SetTag(string(tag), value)
-}

vendor/github.com/opentracing/opentracing-go/globaltracer.go

@@ -1,42 +0,0 @@
-package opentracing
-
-type registeredTracer struct {
-	tracer       Tracer
-	isRegistered bool
-}
-
-var (
-	globalTracer = registeredTracer{NoopTracer{}, false}
-)
-
-// SetGlobalTracer sets the [singleton] opentracing.Tracer returned by
-// GlobalTracer(). Those who use GlobalTracer (rather than directly manage an
-// opentracing.Tracer instance) should call SetGlobalTracer as early as
-// possible in main(), prior to calling the `StartSpan` global func below.
-// Prior to calling `SetGlobalTracer`, any Spans started via the `StartSpan`
-// (etc) globals are noops.
-func SetGlobalTracer(tracer Tracer) {
-	globalTracer = registeredTracer{tracer, true}
-}
-
-// GlobalTracer returns the global singleton `Tracer` implementation.
-// Before `SetGlobalTracer()` is called, the `GlobalTracer()` is a noop
-// implementation that drops all data handed to it.
-func GlobalTracer() Tracer {
-	return globalTracer.tracer
-}
-
-// StartSpan defers to `Tracer.StartSpan`. See `GlobalTracer()`.
-func StartSpan(operationName string, opts ...StartSpanOption) Span {
-	return globalTracer.tracer.StartSpan(operationName, opts...)
-}
-
-// InitGlobalTracer is deprecated. Please use SetGlobalTracer.
-func InitGlobalTracer(tracer Tracer) {
-	SetGlobalTracer(tracer)
-}
-
-// IsGlobalTracerRegistered returns a `bool` to indicate if a tracer has been globally registered
-func IsGlobalTracerRegistered() bool {
-	return globalTracer.isRegistered
-}

vendor/github.com/opentracing/opentracing-go/gocontext.go

@@ -1,65 +0,0 @@
-package opentracing
-
-import "context"
-
-type contextKey struct{}
-
-var activeSpanKey = contextKey{}
-
-// ContextWithSpan returns a new `context.Context` that holds a reference to
-// the span. If span is nil, a new context without an active span is returned.
-func ContextWithSpan(ctx context.Context, span Span) context.Context {
-	if span != nil {
-		if tracerWithHook, ok := span.Tracer().(TracerContextWithSpanExtension); ok {
-			ctx = tracerWithHook.ContextWithSpanHook(ctx, span)
-		}
-	}
-	return context.WithValue(ctx, activeSpanKey, span)
-}
-
-// SpanFromContext returns the `Span` previously associated with `ctx`, or
-// `nil` if no such `Span` could be found.
-//
-// NOTE: context.Context != SpanContext: the former is Go's intra-process
-// context propagation mechanism, and the latter houses OpenTracing's per-Span
-// identity and baggage information.
-func SpanFromContext(ctx context.Context) Span {
-	val := ctx.Value(activeSpanKey)
-	if sp, ok := val.(Span); ok {
-		return sp
-	}
-	return nil
-}
-
-// StartSpanFromContext starts and returns a Span with `operationName`, using
-// any Span found within `ctx` as a ChildOfRef. If no such parent could be
-// found, StartSpanFromContext creates a root (parentless) Span.
-//
-// The second return value is a context.Context object built around the
-// returned Span.
-//
-// Example usage:
-//
-//    SomeFunction(ctx context.Context, ...) {
-//        sp, ctx := opentracing.StartSpanFromContext(ctx, "SomeFunction")
-//        defer sp.Finish()
-//        ...
-//    }
-func StartSpanFromContext(ctx context.Context, operationName string, opts ...StartSpanOption) (Span, context.Context) {
-	return StartSpanFromContextWithTracer(ctx, GlobalTracer(), operationName, opts...)
-}
-
-// StartSpanFromContextWithTracer starts and returns a span with `operationName`
-// using  a span found within the context as a ChildOfRef. If that doesn't exist
-// it creates a root span. It also returns a context.Context object built
-// around the returned span.
-//
-// It's behavior is identical to StartSpanFromContext except that it takes an explicit
-// tracer as opposed to using the global tracer.
-func StartSpanFromContextWithTracer(ctx context.Context, tracer Tracer, operationName string, opts ...StartSpanOption) (Span, context.Context) {
-	if parentSpan := SpanFromContext(ctx); parentSpan != nil {
-		opts = append(opts, ChildOf(parentSpan.Context()))
-	}
-	span := tracer.StartSpan(operationName, opts...)
-	return span, ContextWithSpan(ctx, span)
-}

vendor/github.com/opentracing/opentracing-go/log/field.go

@@ -1,282 +0,0 @@
-package log
-
-import (
-	"fmt"
-	"math"
-)
-
-type fieldType int
-
-const (
-	stringType fieldType = iota
-	boolType
-	intType
-	int32Type
-	uint32Type
-	int64Type
-	uint64Type
-	float32Type
-	float64Type
-	errorType
-	objectType
-	lazyLoggerType
-	noopType
-)
-
-// Field instances are constructed via LogBool, LogString, and so on.
-// Tracing implementations may then handle them via the Field.Marshal
-// method.
-//
-// "heavily influenced by" (i.e., partially stolen from)
-// https://github.com/uber-go/zap
-type Field struct {
-	key          string
-	fieldType    fieldType
-	numericVal   int64
-	stringVal    string
-	interfaceVal interface{}
-}
-
-// String adds a string-valued key:value pair to a Span.LogFields() record
-func String(key, val string) Field {
-	return Field{
-		key:       key,
-		fieldType: stringType,
-		stringVal: val,
-	}
-}
-
-// Bool adds a bool-valued key:value pair to a Span.LogFields() record
-func Bool(key string, val bool) Field {
-	var numericVal int64
-	if val {
-		numericVal = 1
-	}
-	return Field{
-		key:        key,
-		fieldType:  boolType,
-		numericVal: numericVal,
-	}
-}
-
-// Int adds an int-valued key:value pair to a Span.LogFields() record
-func Int(key string, val int) Field {
-	return Field{
-		key:        key,
-		fieldType:  intType,
-		numericVal: int64(val),
-	}
-}
-
-// Int32 adds an int32-valued key:value pair to a Span.LogFields() record
-func Int32(key string, val int32) Field {
-	return Field{
-		key:        key,
-		fieldType:  int32Type,
-		numericVal: int64(val),
-	}
-}
-
-// Int64 adds an int64-valued key:value pair to a Span.LogFields() record
-func Int64(key string, val int64) Field {
-	return Field{
-		key:        key,
-		fieldType:  int64Type,
-		numericVal: val,
-	}
-}
-
-// Uint32 adds a uint32-valued key:value pair to a Span.LogFields() record
-func Uint32(key string, val uint32) Field {
-	return Field{
-		key:        key,
-		fieldType:  uint32Type,
-		numericVal: int64(val),
-	}
-}
-
-// Uint64 adds a uint64-valued key:value pair to a Span.LogFields() record
-func Uint64(key string, val uint64) Field {
-	return Field{
-		key:        key,
-		fieldType:  uint64Type,
-		numericVal: int64(val),
-	}
-}
-
-// Float32 adds a float32-valued key:value pair to a Span.LogFields() record
-func Float32(key string, val float32) Field {
-	return Field{
-		key:        key,
-		fieldType:  float32Type,
-		numericVal: int64(math.Float32bits(val)),
-	}
-}
-
-// Float64 adds a float64-valued key:value pair to a Span.LogFields() record
-func Float64(key string, val float64) Field {
-	return Field{
-		key:        key,
-		fieldType:  float64Type,
-		numericVal: int64(math.Float64bits(val)),
-	}
-}
-
-// Error adds an error with the key "error.object" to a Span.LogFields() record
-func Error(err error) Field {
-	return Field{
-		key:          "error.object",
-		fieldType:    errorType,
-		interfaceVal: err,
-	}
-}
-
-// Object adds an object-valued key:value pair to a Span.LogFields() record
-// Please pass in an immutable object, otherwise there may be concurrency issues.
-// Such as passing in the map, log.Object may result in "fatal error: concurrent map iteration and map write".
-// Because span is sent asynchronously, it is possible that this map will also be modified.
-func Object(key string, obj interface{}) Field {
-	return Field{
-		key:          key,
-		fieldType:    objectType,
-		interfaceVal: obj,
-	}
-}
-
-// Event creates a string-valued Field for span logs with key="event" and value=val.
-func Event(val string) Field {
-	return String("event", val)
-}
-
-// Message creates a string-valued Field for span logs with key="message" and value=val.
-func Message(val string) Field {
-	return String("message", val)
-}
-
-// LazyLogger allows for user-defined, late-bound logging of arbitrary data
-type LazyLogger func(fv Encoder)
-
-// Lazy adds a LazyLogger to a Span.LogFields() record; the tracing
-// implementation will call the LazyLogger function at an indefinite time in
-// the future (after Lazy() returns).
-func Lazy(ll LazyLogger) Field {
-	return Field{
-		fieldType:    lazyLoggerType,
-		interfaceVal: ll,
-	}
-}
-
-// Noop creates a no-op log field that should be ignored by the tracer.
-// It can be used to capture optional fields, for example those that should
-// only be logged in non-production environment:
-//
-//     func customerField(order *Order) log.Field {
-//          if os.Getenv("ENVIRONMENT") == "dev" {
-//              return log.String("customer", order.Customer.ID)
-//          }
-//          return log.Noop()
-//     }
-//
-//     span.LogFields(log.String("event", "purchase"), customerField(order))
-//
-func Noop() Field {
-	return Field{
-		fieldType: noopType,
-	}
-}
-
-// Encoder allows access to the contents of a Field (via a call to
-// Field.Marshal).
-//
-// Tracer implementations typically provide an implementation of Encoder;
-// OpenTracing callers typically do not need to concern themselves with it.
-type Encoder interface {
-	EmitString(key, value string)
-	EmitBool(key string, value bool)
-	EmitInt(key string, value int)
-	EmitInt32(key string, value int32)
-	EmitInt64(key string, value int64)
-	EmitUint32(key string, value uint32)
-	EmitUint64(key string, value uint64)
-	EmitFloat32(key string, value float32)
-	EmitFloat64(key string, value float64)
-	EmitObject(key string, value interface{})
-	EmitLazyLogger(value LazyLogger)
-}
-
-// Marshal passes a Field instance through to the appropriate
-// field-type-specific method of an Encoder.
-func (lf Field) Marshal(visitor Encoder) {
-	switch lf.fieldType {
-	case stringType:
-		visitor.EmitString(lf.key, lf.stringVal)
-	case boolType:
-		visitor.EmitBool(lf.key, lf.numericVal != 0)
-	case intType:
-		visitor.EmitInt(lf.key, int(lf.numericVal))
-	case int32Type:
-		visitor.EmitInt32(lf.key, int32(lf.numericVal))
-	case int64Type:
-		visitor.EmitInt64(lf.key, int64(lf.numericVal))
-	case uint32Type:
-		visitor.EmitUint32(lf.key, uint32(lf.numericVal))
-	case uint64Type:
-		visitor.EmitUint64(lf.key, uint64(lf.numericVal))
-	case float32Type:
-		visitor.EmitFloat32(lf.key, math.Float32frombits(uint32(lf.numericVal)))
-	case float64Type:
-		visitor.EmitFloat64(lf.key, math.Float64frombits(uint64(lf.numericVal)))
-	case errorType:
-		if err, ok := lf.interfaceVal.(error); ok {
-			visitor.EmitString(lf.key, err.Error())
-		} else {
-			visitor.EmitString(lf.key, "<nil>")
-		}
-	case objectType:
-		visitor.EmitObject(lf.key, lf.interfaceVal)
-	case lazyLoggerType:
-		visitor.EmitLazyLogger(lf.interfaceVal.(LazyLogger))
-	case noopType:
-		// intentionally left blank
-	}
-}
-
-// Key returns the field's key.
-func (lf Field) Key() string {
-	return lf.key
-}
-
-// Value returns the field's value as interface{}.
-func (lf Field) Value() interface{} {
-	switch lf.fieldType {
-	case stringType:
-		return lf.stringVal
-	case boolType:
-		return lf.numericVal != 0
-	case intType:
-		return int(lf.numericVal)
-	case int32Type:
-		return int32(lf.numericVal)
-	case int64Type:
-		return int64(lf.numericVal)
-	case uint32Type:
-		return uint32(lf.numericVal)
-	case uint64Type:
-		return uint64(lf.numericVal)
-	case float32Type:
-		return math.Float32frombits(uint32(lf.numericVal))
-	case float64Type:
-		return math.Float64frombits(uint64(lf.numericVal))
-	case errorType, objectType, lazyLoggerType:
-		return lf.interfaceVal
-	case noopType:
-		return nil
-	default:
-		return nil
-	}
-}
-
-// String returns a string representation of the key and value.
-func (lf Field) String() string {
-	return fmt.Sprint(lf.key, ":", lf.Value())
-}

vendor/github.com/opentracing/opentracing-go/log/util.go

@@ -1,61 +0,0 @@
-package log
-
-import (
-	"fmt"
-	"reflect"
-)
-
-// InterleavedKVToFields converts keyValues a la Span.LogKV() to a Field slice
-// a la Span.LogFields().
-func InterleavedKVToFields(keyValues ...interface{}) ([]Field, error) {
-	if len(keyValues)%2 != 0 {
-		return nil, fmt.Errorf("non-even keyValues len: %d", len(keyValues))
-	}
-	fields := make([]Field, len(keyValues)/2)
-	for i := 0; i*2 < len(keyValues); i++ {
-		key, ok := keyValues[i*2].(string)
-		if !ok {
-			return nil, fmt.Errorf(
-				"non-string key (pair #%d): %T",
-				i, keyValues[i*2])
-		}
-		switch typedVal := keyValues[i*2+1].(type) {
-		case bool:
-			fields[i] = Bool(key, typedVal)
-		case string:
-			fields[i] = String(key, typedVal)
-		case int:
-			fields[i] = Int(key, typedVal)
-		case int8:
-			fields[i] = Int32(key, int32(typedVal))
-		case int16:
-			fields[i] = Int32(key, int32(typedVal))
-		case int32:
-			fields[i] = Int32(key, typedVal)
-		case int64:
-			fields[i] = Int64(key, typedVal)
-		case uint:
-			fields[i] = Uint64(key, uint64(typedVal))
-		case uint64:
-			fields[i] = Uint64(key, typedVal)
-		case uint8:
-			fields[i] = Uint32(key, uint32(typedVal))
-		case uint16:
-			fields[i] = Uint32(key, uint32(typedVal))
-		case uint32:
-			fields[i] = Uint32(key, typedVal)
-		case float32:
-			fields[i] = Float32(key, typedVal)
-		case float64:
-			fields[i] = Float64(key, typedVal)
-		default:
-			if typedVal == nil || (reflect.ValueOf(typedVal).Kind() == reflect.Ptr && reflect.ValueOf(typedVal).IsNil()) {
-				fields[i] = String(key, "nil")
-				continue
-			}
-			// When in doubt, coerce to a string
-			fields[i] = String(key, fmt.Sprint(typedVal))
-		}
-	}
-	return fields, nil
-}

vendor/github.com/opentracing/opentracing-go/noop.go

@@ -1,64 +0,0 @@
-package opentracing
-
-import "github.com/opentracing/opentracing-go/log"
-
-// A NoopTracer is a trivial, minimum overhead implementation of Tracer
-// for which all operations are no-ops.
-//
-// The primary use of this implementation is in libraries, such as RPC
-// frameworks, that make tracing an optional feature controlled by the
-// end user. A no-op implementation allows said libraries to use it
-// as the default Tracer and to write instrumentation that does
-// not need to keep checking if the tracer instance is nil.
-//
-// For the same reason, the NoopTracer is the default "global" tracer
-// (see GlobalTracer and SetGlobalTracer functions).
-//
-// WARNING: NoopTracer does not support baggage propagation.
-type NoopTracer struct{}
-
-type noopSpan struct{}
-type noopSpanContext struct{}
-
-var (
-	defaultNoopSpanContext SpanContext = noopSpanContext{}
-	defaultNoopSpan        Span        = noopSpan{}
-	defaultNoopTracer      Tracer      = NoopTracer{}
-)
-
-const (
-	emptyString = ""
-)
-
-// noopSpanContext:
-func (n noopSpanContext) ForeachBaggageItem(handler func(k, v string) bool) {}
-
-// noopSpan:
-func (n noopSpan) Context() SpanContext                                  { return defaultNoopSpanContext }
-func (n noopSpan) SetBaggageItem(key, val string) Span                   { return n }
-func (n noopSpan) BaggageItem(key string) string                         { return emptyString }
-func (n noopSpan) SetTag(key string, value interface{}) Span             { return n }
-func (n noopSpan) LogFields(fields ...log.Field)                         {}
-func (n noopSpan) LogKV(keyVals ...interface{})                          {}
-func (n noopSpan) Finish()                                               {}
-func (n noopSpan) FinishWithOptions(opts FinishOptions)                  {}
-func (n noopSpan) SetOperationName(operationName string) Span            { return n }
-func (n noopSpan) Tracer() Tracer                                        { return defaultNoopTracer }
-func (n noopSpan) LogEvent(event string)                                 {}
-func (n noopSpan) LogEventWithPayload(event string, payload interface{}) {}
-func (n noopSpan) Log(data LogData)                                      {}
-
-// StartSpan belongs to the Tracer interface.
-func (n NoopTracer) StartSpan(operationName string, opts ...StartSpanOption) Span {
-	return defaultNoopSpan
-}
-
-// Inject belongs to the Tracer interface.
-func (n NoopTracer) Inject(sp SpanContext, format interface{}, carrier interface{}) error {
-	return nil
-}
-
-// Extract belongs to the Tracer interface.
-func (n NoopTracer) Extract(format interface{}, carrier interface{}) (SpanContext, error) {
-	return nil, ErrSpanContextNotFound
-}

vendor/github.com/opentracing/opentracing-go/propagation.go

@@ -1,176 +0,0 @@
-package opentracing
-
-import (
-	"errors"
-	"net/http"
-)
-
-///////////////////////////////////////////////////////////////////////////////
-// CORE PROPAGATION INTERFACES:
-///////////////////////////////////////////////////////////////////////////////
-
-var (
-	// ErrUnsupportedFormat occurs when the `format` passed to Tracer.Inject() or
-	// Tracer.Extract() is not recognized by the Tracer implementation.
-	ErrUnsupportedFormat = errors.New("opentracing: Unknown or unsupported Inject/Extract format")
-
-	// ErrSpanContextNotFound occurs when the `carrier` passed to
-	// Tracer.Extract() is valid and uncorrupted but has insufficient
-	// information to extract a SpanContext.
-	ErrSpanContextNotFound = errors.New("opentracing: SpanContext not found in Extract carrier")
-
-	// ErrInvalidSpanContext errors occur when Tracer.Inject() is asked to
-	// operate on a SpanContext which it is not prepared to handle (for
-	// example, since it was created by a different tracer implementation).
-	ErrInvalidSpanContext = errors.New("opentracing: SpanContext type incompatible with tracer")
-
-	// ErrInvalidCarrier errors occur when Tracer.Inject() or Tracer.Extract()
-	// implementations expect a different type of `carrier` than they are
-	// given.
-	ErrInvalidCarrier = errors.New("opentracing: Invalid Inject/Extract carrier")
-
-	// ErrSpanContextCorrupted occurs when the `carrier` passed to
-	// Tracer.Extract() is of the expected type but is corrupted.
-	ErrSpanContextCorrupted = errors.New("opentracing: SpanContext data corrupted in Extract carrier")
-)
-
-///////////////////////////////////////////////////////////////////////////////
-// BUILTIN PROPAGATION FORMATS:
-///////////////////////////////////////////////////////////////////////////////
-
-// BuiltinFormat is used to demarcate the values within package `opentracing`
-// that are intended for use with the Tracer.Inject() and Tracer.Extract()
-// methods.
-type BuiltinFormat byte
-
-const (
-	// Binary represents SpanContexts as opaque binary data.
-	//
-	// For Tracer.Inject(): the carrier must be an `io.Writer`.
-	//
-	// For Tracer.Extract(): the carrier must be an `io.Reader`.
-	Binary BuiltinFormat = iota
-
-	// TextMap represents SpanContexts as key:value string pairs.
-	//
-	// Unlike HTTPHeaders, the TextMap format does not restrict the key or
-	// value character sets in any way.
-	//
-	// For Tracer.Inject(): the carrier must be a `TextMapWriter`.
-	//
-	// For Tracer.Extract(): the carrier must be a `TextMapReader`.
-	TextMap
-
-	// HTTPHeaders represents SpanContexts as HTTP header string pairs.
-	//
-	// Unlike TextMap, the HTTPHeaders format requires that the keys and values
-	// be valid as HTTP headers as-is (i.e., character casing may be unstable
-	// and special characters are disallowed in keys, values should be
-	// URL-escaped, etc).
-	//
-	// For Tracer.Inject(): the carrier must be a `TextMapWriter`.
-	//
-	// For Tracer.Extract(): the carrier must be a `TextMapReader`.
-	//
-	// See HTTPHeadersCarrier for an implementation of both TextMapWriter
-	// and TextMapReader that defers to an http.Header instance for storage.
-	// For example, Inject():
-	//
-	//    carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
-	//    err := span.Tracer().Inject(
-	//        span.Context(), opentracing.HTTPHeaders, carrier)
-	//
-	// Or Extract():
-	//
-	//    carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
-	//    clientContext, err := tracer.Extract(
-	//        opentracing.HTTPHeaders, carrier)
-	//
-	HTTPHeaders
-)
-
-// TextMapWriter is the Inject() carrier for the TextMap builtin format. With
-// it, the caller can encode a SpanContext for propagation as entries in a map
-// of unicode strings.
-type TextMapWriter interface {
-	// Set a key:value pair to the carrier. Multiple calls to Set() for the
-	// same key leads to undefined behavior.
-	//
-	// NOTE: The backing store for the TextMapWriter may contain data unrelated
-	// to SpanContext. As such, Inject() and Extract() implementations that
-	// call the TextMapWriter and TextMapReader interfaces must agree on a
-	// prefix or other convention to distinguish their own key:value pairs.
-	Set(key, val string)
-}
-
-// TextMapReader is the Extract() carrier for the TextMap builtin format. With it,
-// the caller can decode a propagated SpanContext as entries in a map of
-// unicode strings.
-type TextMapReader interface {
-	// ForeachKey returns TextMap contents via repeated calls to the `handler`
-	// function. If any call to `handler` returns a non-nil error, ForeachKey
-	// terminates and returns that error.
-	//
-	// NOTE: The backing store for the TextMapReader may contain data unrelated
-	// to SpanContext. As such, Inject() and Extract() implementations that
-	// call the TextMapWriter and TextMapReader interfaces must agree on a
-	// prefix or other convention to distinguish their own key:value pairs.
-	//
-	// The "foreach" callback pattern reduces unnecessary copying in some cases
-	// and also allows implementations to hold locks while the map is read.
-	ForeachKey(handler func(key, val string) error) error
-}
-
-// TextMapCarrier allows the use of regular map[string]string
-// as both TextMapWriter and TextMapReader.
-type TextMapCarrier map[string]string
-
-// ForeachKey conforms to the TextMapReader interface.
-func (c TextMapCarrier) ForeachKey(handler func(key, val string) error) error {
-	for k, v := range c {
-		if err := handler(k, v); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Set implements Set() of opentracing.TextMapWriter
-func (c TextMapCarrier) Set(key, val string) {
-	c[key] = val
-}
-
-// HTTPHeadersCarrier satisfies both TextMapWriter and TextMapReader.
-//
-// Example usage for server side:
-//
-//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
-//     clientContext, err := tracer.Extract(opentracing.HTTPHeaders, carrier)
-//
-// Example usage for client side:
-//
-//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
-//     err := tracer.Inject(
-//         span.Context(),
-//         opentracing.HTTPHeaders,
-//         carrier)
-//
-type HTTPHeadersCarrier http.Header
-
-// Set conforms to the TextMapWriter interface.
-func (c HTTPHeadersCarrier) Set(key, val string) {
-	h := http.Header(c)
-	h.Set(key, val)
-}
-
-// ForeachKey conforms to the TextMapReader interface.
-func (c HTTPHeadersCarrier) ForeachKey(handler func(key, val string) error) error {
-	for k, vals := range c {
-		for _, v := range vals {
-			if err := handler(k, v); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}

vendor/github.com/opentracing/opentracing-go/span.go

@@ -1,189 +0,0 @@
-package opentracing
-
-import (
-	"time"
-
-	"github.com/opentracing/opentracing-go/log"
-)
-
-// SpanContext represents Span state that must propagate to descendant Spans and across process
-// boundaries (e.g., a <trace_id, span_id, sampled> tuple).
-type SpanContext interface {
-	// ForeachBaggageItem grants access to all baggage items stored in the
-	// SpanContext.
-	// The handler function will be called for each baggage key/value pair.
-	// The ordering of items is not guaranteed.
-	//
-	// The bool return value indicates if the handler wants to continue iterating
-	// through the rest of the baggage items; for example if the handler is trying to
-	// find some baggage item by pattern matching the name, it can return false
-	// as soon as the item is found to stop further iterations.
-	ForeachBaggageItem(handler func(k, v string) bool)
-}
-
-// Span represents an active, un-finished span in the OpenTracing system.
-//
-// Spans are created by the Tracer interface.
-type Span interface {
-	// Sets the end timestamp and finalizes Span state.
-	//
-	// With the exception of calls to Context() (which are always allowed),
-	// Finish() must be the last call made to any span instance, and to do
-	// otherwise leads to undefined behavior.
-	Finish()
-	// FinishWithOptions is like Finish() but with explicit control over
-	// timestamps and log data.
-	FinishWithOptions(opts FinishOptions)
-
-	// Context() yields the SpanContext for this Span. Note that the return
-	// value of Context() is still valid after a call to Span.Finish(), as is
-	// a call to Span.Context() after a call to Span.Finish().
-	Context() SpanContext
-
-	// Sets or changes the operation name.
-	//
-	// Returns a reference to this Span for chaining.
-	SetOperationName(operationName string) Span
-
-	// Adds a tag to the span.
-	//
-	// If there is a pre-existing tag set for `key`, it is overwritten.
-	//
-	// Tag values can be numeric types, strings, or bools. The behavior of
-	// other tag value types is undefined at the OpenTracing level. If a
-	// tracing system does not know how to handle a particular value type, it
-	// may ignore the tag, but shall not panic.
-	//
-	// Returns a reference to this Span for chaining.
-	SetTag(key string, value interface{}) Span
-
-	// LogFields is an efficient and type-checked way to record key:value
-	// logging data about a Span, though the programming interface is a little
-	// more verbose than LogKV(). Here's an example:
-	//
-	//    span.LogFields(
-	//        log.String("event", "soft error"),
-	//        log.String("type", "cache timeout"),
-	//        log.Int("waited.millis", 1500))
-	//
-	// Also see Span.FinishWithOptions() and FinishOptions.BulkLogData.
-	LogFields(fields ...log.Field)
-
-	// LogKV is a concise, readable way to record key:value logging data about
-	// a Span, though unfortunately this also makes it less efficient and less
-	// type-safe than LogFields(). Here's an example:
-	//
-	//    span.LogKV(
-	//        "event", "soft error",
-	//        "type", "cache timeout",
-	//        "waited.millis", 1500)
-	//
-	// For LogKV (as opposed to LogFields()), the parameters must appear as
-	// key-value pairs, like
-	//
-	//    span.LogKV(key1, val1, key2, val2, key3, val3, ...)
-	//
-	// The keys must all be strings. The values may be strings, numeric types,
-	// bools, Go error instances, or arbitrary structs.
-	//
-	// (Note to implementors: consider the log.InterleavedKVToFields() helper)
-	LogKV(alternatingKeyValues ...interface{})
-
-	// SetBaggageItem sets a key:value pair on this Span and its SpanContext
-	// that also propagates to descendants of this Span.
-	//
-	// SetBaggageItem() enables powerful functionality given a full-stack
-	// opentracing integration (e.g., arbitrary application data from a mobile
-	// app can make it, transparently, all the way into the depths of a storage
-	// system), and with it some powerful costs: use this feature with care.
-	//
-	// IMPORTANT NOTE #1: SetBaggageItem() will only propagate baggage items to
-	// *future* causal descendants of the associated Span.
-	//
-	// IMPORTANT NOTE #2: Use this thoughtfully and with care. Every key and
-	// value is copied into every local *and remote* child of the associated
-	// Span, and that can add up to a lot of network and cpu overhead.
-	//
-	// Returns a reference to this Span for chaining.
-	SetBaggageItem(restrictedKey, value string) Span
-
-	// Gets the value for a baggage item given its key. Returns the empty string
-	// if the value isn't found in this Span.
-	BaggageItem(restrictedKey string) string
-
-	// Provides access to the Tracer that created this Span.
-	Tracer() Tracer
-
-	// Deprecated: use LogFields or LogKV
-	LogEvent(event string)
-	// Deprecated: use LogFields or LogKV
-	LogEventWithPayload(event string, payload interface{})
-	// Deprecated: use LogFields or LogKV
-	Log(data LogData)
-}
-
-// LogRecord is data associated with a single Span log. Every LogRecord
-// instance must specify at least one Field.
-type LogRecord struct {
-	Timestamp time.Time
-	Fields    []log.Field
-}
-
-// FinishOptions allows Span.FinishWithOptions callers to override the finish
-// timestamp and provide log data via a bulk interface.
-type FinishOptions struct {
-	// FinishTime overrides the Span's finish time, or implicitly becomes
-	// time.Now() if FinishTime.IsZero().
-	//
-	// FinishTime must resolve to a timestamp that's >= the Span's StartTime
-	// (per StartSpanOptions).
-	FinishTime time.Time
-
-	// LogRecords allows the caller to specify the contents of many LogFields()
-	// calls with a single slice. May be nil.
-	//
-	// None of the LogRecord.Timestamp values may be .IsZero() (i.e., they must
-	// be set explicitly). Also, they must be >= the Span's start timestamp and
-	// <= the FinishTime (or time.Now() if FinishTime.IsZero()). Otherwise the
-	// behavior of FinishWithOptions() is undefined.
-	//
-	// If specified, the caller hands off ownership of LogRecords at
-	// FinishWithOptions() invocation time.
-	//
-	// If specified, the (deprecated) BulkLogData must be nil or empty.
-	LogRecords []LogRecord
-
-	// BulkLogData is DEPRECATED.
-	BulkLogData []LogData
-}
-
-// LogData is DEPRECATED
-type LogData struct {
-	Timestamp time.Time
-	Event     string
-	Payload   interface{}
-}
-
-// ToLogRecord converts a deprecated LogData to a non-deprecated LogRecord
-func (ld *LogData) ToLogRecord() LogRecord {
-	var literalTimestamp time.Time
-	if ld.Timestamp.IsZero() {
-		literalTimestamp = time.Now()
-	} else {
-		literalTimestamp = ld.Timestamp
-	}
-	rval := LogRecord{
-		Timestamp: literalTimestamp,
-	}
-	if ld.Payload == nil {
-		rval.Fields = []log.Field{
-			log.String("event", ld.Event),
-		}
-	} else {
-		rval.Fields = []log.Field{
-			log.String("event", ld.Event),
-			log.Object("payload", ld.Payload),
-		}
-	}
-	return rval
-}

vendor/github.com/opentracing/opentracing-go/tracer.go

@@ -1,304 +0,0 @@
-package opentracing
-
-import "time"
-
-// Tracer is a simple, thin interface for Span creation and SpanContext
-// propagation.
-type Tracer interface {
-
-	// Create, start, and return a new Span with the given `operationName` and
-	// incorporate the given StartSpanOption `opts`. (Note that `opts` borrows
-	// from the "functional options" pattern, per
-	// http://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis)
-	//
-	// A Span with no SpanReference options (e.g., opentracing.ChildOf() or
-	// opentracing.FollowsFrom()) becomes the root of its own trace.
-	//
-	// Examples:
-	//
-	//     var tracer opentracing.Tracer = ...
-	//
-	//     // The root-span case:
-	//     sp := tracer.StartSpan("GetFeed")
-	//
-	//     // The vanilla child span case:
-	//     sp := tracer.StartSpan(
-	//         "GetFeed",
-	//         opentracing.ChildOf(parentSpan.Context()))
-	//
-	//     // All the bells and whistles:
-	//     sp := tracer.StartSpan(
-	//         "GetFeed",
-	//         opentracing.ChildOf(parentSpan.Context()),
-	//         opentracing.Tag{"user_agent", loggedReq.UserAgent},
-	//         opentracing.StartTime(loggedReq.Timestamp),
-	//     )
-	//
-	StartSpan(operationName string, opts ...StartSpanOption) Span
-
-	// Inject() takes the `sm` SpanContext instance and injects it for
-	// propagation within `carrier`. The actual type of `carrier` depends on
-	// the value of `format`.
-	//
-	// OpenTracing defines a common set of `format` values (see BuiltinFormat),
-	// and each has an expected carrier type.
-	//
-	// Other packages may declare their own `format` values, much like the keys
-	// used by `context.Context` (see https://godoc.org/context#WithValue).
-	//
-	// Example usage (sans error handling):
-	//
-	//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
-	//     err := tracer.Inject(
-	//         span.Context(),
-	//         opentracing.HTTPHeaders,
-	//         carrier)
-	//
-	// NOTE: All opentracing.Tracer implementations MUST support all
-	// BuiltinFormats.
-	//
-	// Implementations may return opentracing.ErrUnsupportedFormat if `format`
-	// is not supported by (or not known by) the implementation.
-	//
-	// Implementations may return opentracing.ErrInvalidCarrier or any other
-	// implementation-specific error if the format is supported but injection
-	// fails anyway.
-	//
-	// See Tracer.Extract().
-	Inject(sm SpanContext, format interface{}, carrier interface{}) error
-
-	// Extract() returns a SpanContext instance given `format` and `carrier`.
-	//
-	// OpenTracing defines a common set of `format` values (see BuiltinFormat),
-	// and each has an expected carrier type.
-	//
-	// Other packages may declare their own `format` values, much like the keys
-	// used by `context.Context` (see
-	// https://godoc.org/golang.org/x/net/context#WithValue).
-	//
-	// Example usage (with StartSpan):
-	//
-	//
-	//     carrier := opentracing.HTTPHeadersCarrier(httpReq.Header)
-	//     clientContext, err := tracer.Extract(opentracing.HTTPHeaders, carrier)
-	//
-	//     // ... assuming the ultimate goal here is to resume the trace with a
-	//     // server-side Span:
-	//     var serverSpan opentracing.Span
-	//     if err == nil {
-	//         span = tracer.StartSpan(
-	//             rpcMethodName, ext.RPCServerOption(clientContext))
-	//     } else {
-	//         span = tracer.StartSpan(rpcMethodName)
-	//     }
-	//
-	//
-	// NOTE: All opentracing.Tracer implementations MUST support all
-	// BuiltinFormats.
-	//
-	// Return values:
-	//  - A successful Extract returns a SpanContext instance and a nil error
-	//  - If there was simply no SpanContext to extract in `carrier`, Extract()
-	//    returns (nil, opentracing.ErrSpanContextNotFound)
-	//  - If `format` is unsupported or unrecognized, Extract() returns (nil,
-	//    opentracing.ErrUnsupportedFormat)
-	//  - If there are more fundamental problems with the `carrier` object,
-	//    Extract() may return opentracing.ErrInvalidCarrier,
-	//    opentracing.ErrSpanContextCorrupted, or implementation-specific
-	//    errors.
-	//
-	// See Tracer.Inject().
-	Extract(format interface{}, carrier interface{}) (SpanContext, error)
-}
-
-// StartSpanOptions allows Tracer.StartSpan() callers and implementors a
-// mechanism to override the start timestamp, specify Span References, and make
-// a single Tag or multiple Tags available at Span start time.
-//
-// StartSpan() callers should look at the StartSpanOption interface and
-// implementations available in this package.
-//
-// Tracer implementations can convert a slice of `StartSpanOption` instances
-// into a `StartSpanOptions` struct like so:
-//
-//     func StartSpan(opName string, opts ...opentracing.StartSpanOption) {
-//         sso := opentracing.StartSpanOptions{}
-//         for _, o := range opts {
-//             o.Apply(&sso)
-//         }
-//         ...
-//     }
-//
-type StartSpanOptions struct {
-	// Zero or more causal references to other Spans (via their SpanContext).
-	// If empty, start a "root" Span (i.e., start a new trace).
-	References []SpanReference
-
-	// StartTime overrides the Span's start time, or implicitly becomes
-	// time.Now() if StartTime.IsZero().
-	StartTime time.Time
-
-	// Tags may have zero or more entries; the restrictions on map values are
-	// identical to those for Span.SetTag(). May be nil.
-	//
-	// If specified, the caller hands off ownership of Tags at
-	// StartSpan() invocation time.
-	Tags map[string]interface{}
-}
-
-// StartSpanOption instances (zero or more) may be passed to Tracer.StartSpan.
-//
-// StartSpanOption borrows from the "functional options" pattern, per
-// http://dave.cheney.net/2014/10/17/functional-options-for-friendly-apis
-type StartSpanOption interface {
-	Apply(*StartSpanOptions)
-}
-
-// SpanReferenceType is an enum type describing different categories of
-// relationships between two Spans. If Span-2 refers to Span-1, the
-// SpanReferenceType describes Span-1 from Span-2's perspective. For example,
-// ChildOfRef means that Span-1 created Span-2.
-//
-// NOTE: Span-1 and Span-2 do *not* necessarily depend on each other for
-// completion; e.g., Span-2 may be part of a background job enqueued by Span-1,
-// or Span-2 may be sitting in a distributed queue behind Span-1.
-type SpanReferenceType int
-
-const (
-	// ChildOfRef refers to a parent Span that caused *and* somehow depends
-	// upon the new child Span. Often (but not always), the parent Span cannot
-	// finish until the child Span does.
-	//
-	// An timing diagram for a ChildOfRef that's blocked on the new Span:
-	//
-	//     [-Parent Span---------]
-	//          [-Child Span----]
-	//
-	// See http://opentracing.io/spec/
-	//
-	// See opentracing.ChildOf()
-	ChildOfRef SpanReferenceType = iota
-
-	// FollowsFromRef refers to a parent Span that does not depend in any way
-	// on the result of the new child Span. For instance, one might use
-	// FollowsFromRefs to describe pipeline stages separated by queues,
-	// or a fire-and-forget cache insert at the tail end of a web request.
-	//
-	// A FollowsFromRef Span is part of the same logical trace as the new Span:
-	// i.e., the new Span is somehow caused by the work of its FollowsFromRef.
-	//
-	// All of the following could be valid timing diagrams for children that
-	// "FollowFrom" a parent.
-	//
-	//     [-Parent Span-]  [-Child Span-]
-	//
-	//
-	//     [-Parent Span--]
-	//      [-Child Span-]
-	//
-	//
-	//     [-Parent Span-]
-	//                 [-Child Span-]
-	//
-	// See http://opentracing.io/spec/
-	//
-	// See opentracing.FollowsFrom()
-	FollowsFromRef
-)
-
-// SpanReference is a StartSpanOption that pairs a SpanReferenceType and a
-// referenced SpanContext. See the SpanReferenceType documentation for
-// supported relationships.  If SpanReference is created with
-// ReferencedContext==nil, it has no effect. Thus it allows for a more concise
-// syntax for starting spans:
-//
-//     sc, _ := tracer.Extract(someFormat, someCarrier)
-//     span := tracer.StartSpan("operation", opentracing.ChildOf(sc))
-//
-// The `ChildOf(sc)` option above will not panic if sc == nil, it will just
-// not add the parent span reference to the options.
-type SpanReference struct {
-	Type              SpanReferenceType
-	ReferencedContext SpanContext
-}
-
-// Apply satisfies the StartSpanOption interface.
-func (r SpanReference) Apply(o *StartSpanOptions) {
-	if r.ReferencedContext != nil {
-		o.References = append(o.References, r)
-	}
-}
-
-// ChildOf returns a StartSpanOption pointing to a dependent parent span.
-// If sc == nil, the option has no effect.
-//
-// See ChildOfRef, SpanReference
-func ChildOf(sc SpanContext) SpanReference {
-	return SpanReference{
-		Type:              ChildOfRef,
-		ReferencedContext: sc,
-	}
-}
-
-// FollowsFrom returns a StartSpanOption pointing to a parent Span that caused
-// the child Span but does not directly depend on its result in any way.
-// If sc == nil, the option has no effect.
-//
-// See FollowsFromRef, SpanReference
-func FollowsFrom(sc SpanContext) SpanReference {
-	return SpanReference{
-		Type:              FollowsFromRef,
-		ReferencedContext: sc,
-	}
-}
-
-// StartTime is a StartSpanOption that sets an explicit start timestamp for the
-// new Span.
-type StartTime time.Time
-
-// Apply satisfies the StartSpanOption interface.
-func (t StartTime) Apply(o *StartSpanOptions) {
-	o.StartTime = time.Time(t)
-}
-
-// Tags are a generic map from an arbitrary string key to an opaque value type.
-// The underlying tracing system is responsible for interpreting and
-// serializing the values.
-type Tags map[string]interface{}
-
-// Apply satisfies the StartSpanOption interface.
-func (t Tags) Apply(o *StartSpanOptions) {
-	if o.Tags == nil {
-		o.Tags = make(map[string]interface{})
-	}
-	for k, v := range t {
-		o.Tags[k] = v
-	}
-}
-
-// Tag may be passed as a StartSpanOption to add a tag to new spans,
-// or its Set method may be used to apply the tag to an existing Span,
-// for example:
-//
-// tracer.StartSpan("opName", Tag{"Key", value})
-//
-//   or
-//
-// Tag{"key", value}.Set(span)
-type Tag struct {
-	Key   string
-	Value interface{}
-}
-
-// Apply satisfies the StartSpanOption interface.
-func (t Tag) Apply(o *StartSpanOptions) {
-	if o.Tags == nil {
-		o.Tags = make(map[string]interface{})
-	}
-	o.Tags[t.Key] = t.Value
-}
-
-// Set applies the tag to an existing Span.
-func (t Tag) Set(s Span) {
-	s.SetTag(t.Key, t.Value)
-}

vendor/github.com/pkg/errors/.gitignore

@@ -1,24 +0,0 @@
-# Compiled Object files, Static and Dynamic libs (Shared Objects)
-*.o
-*.a
-*.so
-
-# Folders
-_obj
-_test
-
-# Architecture specific extensions/prefixes
-*.[568vq]
-[568vq].out
-
-*.cgo1.go
-*.cgo2.c
-_cgo_defun.c
-_cgo_gotypes.go
-_cgo_export.*
-
-_testmain.go
-
-*.exe
-*.test
-*.prof

vendor/github.com/pkg/errors/.travis.yml

@@ -1,10 +0,0 @@
-language: go
-go_import_path: github.com/pkg/errors
-go:
-  - 1.11.x
-  - 1.12.x
-  - 1.13.x
-  - tip
-
-script:
-  - make check

vendor/github.com/pkg/errors/LICENSE

@@ -1,23 +0,0 @@
-Copyright (c) 2015, Dave Cheney <dave@cheney.net>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/pkg/errors/Makefile

@@ -1,44 +0,0 @@
-PKGS := github.com/pkg/errors
-SRCDIRS := $(shell go list -f '{{.Dir}}' $(PKGS))
-GO := go
-
-check: test vet gofmt misspell unconvert staticcheck ineffassign unparam
-
-test: 
-	$(GO) test $(PKGS)
-
-vet: | test
-	$(GO) vet $(PKGS)
-
-staticcheck:
-	$(GO) get honnef.co/go/tools/cmd/staticcheck
-	staticcheck -checks all $(PKGS)
-
-misspell:
-	$(GO) get github.com/client9/misspell/cmd/misspell
-	misspell \
-		-locale GB \
-		-error \
-		*.md *.go
-
-unconvert:
-	$(GO) get github.com/mdempsky/unconvert
-	unconvert -v $(PKGS)
-
-ineffassign:
-	$(GO) get github.com/gordonklaus/ineffassign
-	find $(SRCDIRS) -name '*.go' | xargs ineffassign
-
-pedantic: check errcheck
-
-unparam:
-	$(GO) get mvdan.cc/unparam
-	unparam ./...
-
-errcheck:
-	$(GO) get github.com/kisielk/errcheck
-	errcheck $(PKGS)
-
-gofmt:  
-	@echo Checking code is gofmted
-	@test -z "$(shell gofmt -s -l -d -e $(SRCDIRS) | tee /dev/stderr)"

vendor/github.com/pkg/errors/README.md

@@ -1,59 +0,0 @@
-# errors [![Travis-CI](https://travis-ci.org/pkg/errors.svg)](https://travis-ci.org/pkg/errors) [![AppVeyor](https://ci.appveyor.com/api/projects/status/b98mptawhudj53ep/branch/master?svg=true)](https://ci.appveyor.com/project/davecheney/errors/branch/master) [![GoDoc](https://godoc.org/github.com/pkg/errors?status.svg)](http://godoc.org/github.com/pkg/errors) [![Report card](https://goreportcard.com/badge/github.com/pkg/errors)](https://goreportcard.com/report/github.com/pkg/errors) [![Sourcegraph](https://sourcegraph.com/github.com/pkg/errors/-/badge.svg)](https://sourcegraph.com/github.com/pkg/errors?badge)
-
-Package errors provides simple error handling primitives.
-
-`go get github.com/pkg/errors`
-
-The traditional error handling idiom in Go is roughly akin to
-```go
-if err != nil {
-        return err
-}
-```
-which applied recursively up the call stack results in error reports without context or debugging information. The errors package allows programmers to add context to the failure path in their code in a way that does not destroy the original value of the error.
-
-## Adding context to an error
-
-The errors.Wrap function returns a new error that adds context to the original error. For example
-```go
-_, err := ioutil.ReadAll(r)
-if err != nil {
-        return errors.Wrap(err, "read failed")
-}
-```
-## Retrieving the cause of an error
-
-Using `errors.Wrap` constructs a stack of errors, adding context to the preceding error. Depending on the nature of the error it may be necessary to reverse the operation of errors.Wrap to retrieve the original error for inspection. Any error value which implements this interface can be inspected by `errors.Cause`.
-```go
-type causer interface {
-        Cause() error
-}
-```
-`errors.Cause` will recursively retrieve the topmost error which does not implement `causer`, which is assumed to be the original cause. For example:
-```go
-switch err := errors.Cause(err).(type) {
-case *MyError:
-        // handle specifically
-default:
-        // unknown error
-}
-```
-
-[Read the package documentation for more information](https://godoc.org/github.com/pkg/errors).
-
-## Roadmap
-
-With the upcoming [Go2 error proposals](https://go.googlesource.com/proposal/+/master/design/go2draft.md) this package is moving into maintenance mode. The roadmap for a 1.0 release is as follows:
-
-- 0.9. Remove pre Go 1.9 and Go 1.10 support, address outstanding pull requests (if possible)
-- 1.0. Final release.
-
-## Contributing
-
-Because of the Go2 errors changes, this package is not accepting proposals for new functionality. With that said, we welcome pull requests, bug fixes and issue reports. 
-
-Before sending a PR, please discuss your change by raising an issue.
-
-## License
-
-BSD-2-Clause

vendor/github.com/pkg/errors/appveyor.yml

@@ -1,32 +0,0 @@
-version: build-{build}.{branch}
-
-clone_folder: C:\gopath\src\github.com\pkg\errors
-shallow_clone: true # for startup speed
-
-environment:
-  GOPATH: C:\gopath
-
-platform:
-  - x64
-
-# http://www.appveyor.com/docs/installed-software
-install:
-  # some helpful output for debugging builds
-  - go version
-  - go env
-  # pre-installed MinGW at C:\MinGW is 32bit only
-  # but MSYS2 at C:\msys64 has mingw64
-  - set PATH=C:\msys64\mingw64\bin;%PATH%
-  - gcc --version
-  - g++ --version
-
-build_script:
-  - go install -v ./...
-
-test_script:
-  - set PATH=C:\gopath\bin;%PATH%
-  - go test -v ./...
-
-#artifacts:
-#  - path: '%GOPATH%\bin\*.exe'
-deploy: off

vendor/github.com/pkg/errors/errors.go

@@ -1,288 +0,0 @@
-// Package errors provides simple error handling primitives.
-//
-// The traditional error handling idiom in Go is roughly akin to
-//
-//     if err != nil {
-//             return err
-//     }
-//
-// which when applied recursively up the call stack results in error reports
-// without context or debugging information. The errors package allows
-// programmers to add context to the failure path in their code in a way
-// that does not destroy the original value of the error.
-//
-// Adding context to an error
-//
-// The errors.Wrap function returns a new error that adds context to the
-// original error by recording a stack trace at the point Wrap is called,
-// together with the supplied message. For example
-//
-//     _, err := ioutil.ReadAll(r)
-//     if err != nil {
-//             return errors.Wrap(err, "read failed")
-//     }
-//
-// If additional control is required, the errors.WithStack and
-// errors.WithMessage functions destructure errors.Wrap into its component
-// operations: annotating an error with a stack trace and with a message,
-// respectively.
-//
-// Retrieving the cause of an error
-//
-// Using errors.Wrap constructs a stack of errors, adding context to the
-// preceding error. Depending on the nature of the error it may be necessary
-// to reverse the operation of errors.Wrap to retrieve the original error
-// for inspection. Any error value which implements this interface
-//
-//     type causer interface {
-//             Cause() error
-//     }
-//
-// can be inspected by errors.Cause. errors.Cause will recursively retrieve
-// the topmost error that does not implement causer, which is assumed to be
-// the original cause. For example:
-//
-//     switch err := errors.Cause(err).(type) {
-//     case *MyError:
-//             // handle specifically
-//     default:
-//             // unknown error
-//     }
-//
-// Although the causer interface is not exported by this package, it is
-// considered a part of its stable public interface.
-//
-// Formatted printing of errors
-//
-// All error values returned from this package implement fmt.Formatter and can
-// be formatted by the fmt package. The following verbs are supported:
-//
-//     %s    print the error. If the error has a Cause it will be
-//           printed recursively.
-//     %v    see %s
-//     %+v   extended format. Each Frame of the error's StackTrace will
-//           be printed in detail.
-//
-// Retrieving the stack trace of an error or wrapper
-//
-// New, Errorf, Wrap, and Wrapf record a stack trace at the point they are
-// invoked. This information can be retrieved with the following interface:
-//
-//     type stackTracer interface {
-//             StackTrace() errors.StackTrace
-//     }
-//
-// The returned errors.StackTrace type is defined as
-//
-//     type StackTrace []Frame
-//
-// The Frame type represents a call site in the stack trace. Frame supports
-// the fmt.Formatter interface that can be used for printing information about
-// the stack trace of this error. For example:
-//
-//     if err, ok := err.(stackTracer); ok {
-//             for _, f := range err.StackTrace() {
-//                     fmt.Printf("%+s:%d\n", f, f)
-//             }
-//     }
-//
-// Although the stackTracer interface is not exported by this package, it is
-// considered a part of its stable public interface.
-//
-// See the documentation for Frame.Format for more details.
-package errors
-
-import (
-	"fmt"
-	"io"
-)
-
-// New returns an error with the supplied message.
-// New also records the stack trace at the point it was called.
-func New(message string) error {
-	return &fundamental{
-		msg:   message,
-		stack: callers(),
-	}
-}
-
-// Errorf formats according to a format specifier and returns the string
-// as a value that satisfies error.
-// Errorf also records the stack trace at the point it was called.
-func Errorf(format string, args ...interface{}) error {
-	return &fundamental{
-		msg:   fmt.Sprintf(format, args...),
-		stack: callers(),
-	}
-}
-
-// fundamental is an error that has a message and a stack, but no caller.
-type fundamental struct {
-	msg string
-	*stack
-}
-
-func (f *fundamental) Error() string { return f.msg }
-
-func (f *fundamental) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		if s.Flag('+') {
-			io.WriteString(s, f.msg)
-			f.stack.Format(s, verb)
-			return
-		}
-		fallthrough
-	case 's':
-		io.WriteString(s, f.msg)
-	case 'q':
-		fmt.Fprintf(s, "%q", f.msg)
-	}
-}
-
-// WithStack annotates err with a stack trace at the point WithStack was called.
-// If err is nil, WithStack returns nil.
-func WithStack(err error) error {
-	if err == nil {
-		return nil
-	}
-	return &withStack{
-		err,
-		callers(),
-	}
-}
-
-type withStack struct {
-	error
-	*stack
-}
-
-func (w *withStack) Cause() error { return w.error }
-
-// Unwrap provides compatibility for Go 1.13 error chains.
-func (w *withStack) Unwrap() error { return w.error }
-
-func (w *withStack) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		if s.Flag('+') {
-			fmt.Fprintf(s, "%+v", w.Cause())
-			w.stack.Format(s, verb)
-			return
-		}
-		fallthrough
-	case 's':
-		io.WriteString(s, w.Error())
-	case 'q':
-		fmt.Fprintf(s, "%q", w.Error())
-	}
-}
-
-// Wrap returns an error annotating err with a stack trace
-// at the point Wrap is called, and the supplied message.
-// If err is nil, Wrap returns nil.
-func Wrap(err error, message string) error {
-	if err == nil {
-		return nil
-	}
-	err = &withMessage{
-		cause: err,
-		msg:   message,
-	}
-	return &withStack{
-		err,
-		callers(),
-	}
-}
-
-// Wrapf returns an error annotating err with a stack trace
-// at the point Wrapf is called, and the format specifier.
-// If err is nil, Wrapf returns nil.
-func Wrapf(err error, format string, args ...interface{}) error {
-	if err == nil {
-		return nil
-	}
-	err = &withMessage{
-		cause: err,
-		msg:   fmt.Sprintf(format, args...),
-	}
-	return &withStack{
-		err,
-		callers(),
-	}
-}
-
-// WithMessage annotates err with a new message.
-// If err is nil, WithMessage returns nil.
-func WithMessage(err error, message string) error {
-	if err == nil {
-		return nil
-	}
-	return &withMessage{
-		cause: err,
-		msg:   message,
-	}
-}
-
-// WithMessagef annotates err with the format specifier.
-// If err is nil, WithMessagef returns nil.
-func WithMessagef(err error, format string, args ...interface{}) error {
-	if err == nil {
-		return nil
-	}
-	return &withMessage{
-		cause: err,
-		msg:   fmt.Sprintf(format, args...),
-	}
-}
-
-type withMessage struct {
-	cause error
-	msg   string
-}
-
-func (w *withMessage) Error() string { return w.msg + ": " + w.cause.Error() }
-func (w *withMessage) Cause() error  { return w.cause }
-
-// Unwrap provides compatibility for Go 1.13 error chains.
-func (w *withMessage) Unwrap() error { return w.cause }
-
-func (w *withMessage) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		if s.Flag('+') {
-			fmt.Fprintf(s, "%+v\n", w.Cause())
-			io.WriteString(s, w.msg)
-			return
-		}
-		fallthrough
-	case 's', 'q':
-		io.WriteString(s, w.Error())
-	}
-}
-
-// Cause returns the underlying cause of the error, if possible.
-// An error value has a cause if it implements the following
-// interface:
-//
-//     type causer interface {
-//            Cause() error
-//     }
-//
-// If the error does not implement Cause, the original error will
-// be returned. If the error is nil, nil will be returned without further
-// investigation.
-func Cause(err error) error {
-	type causer interface {
-		Cause() error
-	}
-
-	for err != nil {
-		cause, ok := err.(causer)
-		if !ok {
-			break
-		}
-		err = cause.Cause()
-	}
-	return err
-}

vendor/github.com/pkg/errors/go113.go

@@ -1,38 +0,0 @@
-// +build go1.13
-
-package errors
-
-import (
-	stderrors "errors"
-)
-
-// Is reports whether any error in err's chain matches target.
-//
-// The chain consists of err itself followed by the sequence of errors obtained by
-// repeatedly calling Unwrap.
-//
-// An error is considered to match a target if it is equal to that target or if
-// it implements a method Is(error) bool such that Is(target) returns true.
-func Is(err, target error) bool { return stderrors.Is(err, target) }
-
-// As finds the first error in err's chain that matches target, and if so, sets
-// target to that error value and returns true.
-//
-// The chain consists of err itself followed by the sequence of errors obtained by
-// repeatedly calling Unwrap.
-//
-// An error matches target if the error's concrete value is assignable to the value
-// pointed to by target, or if the error has a method As(interface{}) bool such that
-// As(target) returns true. In the latter case, the As method is responsible for
-// setting target.
-//
-// As will panic if target is not a non-nil pointer to either a type that implements
-// error, or to any interface type. As returns false if err is nil.
-func As(err error, target interface{}) bool { return stderrors.As(err, target) }
-
-// Unwrap returns the result of calling the Unwrap method on err, if err's
-// type contains an Unwrap method returning error.
-// Otherwise, Unwrap returns nil.
-func Unwrap(err error) error {
-	return stderrors.Unwrap(err)
-}

vendor/github.com/pkg/errors/stack.go

@@ -1,177 +0,0 @@
-package errors
-
-import (
-	"fmt"
-	"io"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-)
-
-// Frame represents a program counter inside a stack frame.
-// For historical reasons if Frame is interpreted as a uintptr
-// its value represents the program counter + 1.
-type Frame uintptr
-
-// pc returns the program counter for this frame;
-// multiple frames may have the same PC value.
-func (f Frame) pc() uintptr { return uintptr(f) - 1 }
-
-// file returns the full path to the file that contains the
-// function for this Frame's pc.
-func (f Frame) file() string {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return "unknown"
-	}
-	file, _ := fn.FileLine(f.pc())
-	return file
-}
-
-// line returns the line number of source code of the
-// function for this Frame's pc.
-func (f Frame) line() int {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return 0
-	}
-	_, line := fn.FileLine(f.pc())
-	return line
-}
-
-// name returns the name of this function, if known.
-func (f Frame) name() string {
-	fn := runtime.FuncForPC(f.pc())
-	if fn == nil {
-		return "unknown"
-	}
-	return fn.Name()
-}
-
-// Format formats the frame according to the fmt.Formatter interface.
-//
-//    %s    source file
-//    %d    source line
-//    %n    function name
-//    %v    equivalent to %s:%d
-//
-// Format accepts flags that alter the printing of some verbs, as follows:
-//
-//    %+s   function name and path of source file relative to the compile time
-//          GOPATH separated by \n\t (<funcname>\n\t<path>)
-//    %+v   equivalent to %+s:%d
-func (f Frame) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 's':
-		switch {
-		case s.Flag('+'):
-			io.WriteString(s, f.name())
-			io.WriteString(s, "\n\t")
-			io.WriteString(s, f.file())
-		default:
-			io.WriteString(s, path.Base(f.file()))
-		}
-	case 'd':
-		io.WriteString(s, strconv.Itoa(f.line()))
-	case 'n':
-		io.WriteString(s, funcname(f.name()))
-	case 'v':
-		f.Format(s, 's')
-		io.WriteString(s, ":")
-		f.Format(s, 'd')
-	}
-}
-
-// MarshalText formats a stacktrace Frame as a text string. The output is the
-// same as that of fmt.Sprintf("%+v", f), but without newlines or tabs.
-func (f Frame) MarshalText() ([]byte, error) {
-	name := f.name()
-	if name == "unknown" {
-		return []byte(name), nil
-	}
-	return []byte(fmt.Sprintf("%s %s:%d", name, f.file(), f.line())), nil
-}
-
-// StackTrace is stack of Frames from innermost (newest) to outermost (oldest).
-type StackTrace []Frame
-
-// Format formats the stack of Frames according to the fmt.Formatter interface.
-//
-//    %s	lists source files for each Frame in the stack
-//    %v	lists the source file and line number for each Frame in the stack
-//
-// Format accepts flags that alter the printing of some verbs, as follows:
-//
-//    %+v   Prints filename, function, and line number for each Frame in the stack.
-func (st StackTrace) Format(s fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		switch {
-		case s.Flag('+'):
-			for _, f := range st {
-				io.WriteString(s, "\n")
-				f.Format(s, verb)
-			}
-		case s.Flag('#'):
-			fmt.Fprintf(s, "%#v", []Frame(st))
-		default:
-			st.formatSlice(s, verb)
-		}
-	case 's':
-		st.formatSlice(s, verb)
-	}
-}
-
-// formatSlice will format this StackTrace into the given buffer as a slice of
-// Frame, only valid when called with '%s' or '%v'.
-func (st StackTrace) formatSlice(s fmt.State, verb rune) {
-	io.WriteString(s, "[")
-	for i, f := range st {
-		if i > 0 {
-			io.WriteString(s, " ")
-		}
-		f.Format(s, verb)
-	}
-	io.WriteString(s, "]")
-}
-
-// stack represents a stack of program counters.
-type stack []uintptr
-
-func (s *stack) Format(st fmt.State, verb rune) {
-	switch verb {
-	case 'v':
-		switch {
-		case st.Flag('+'):
-			for _, pc := range *s {
-				f := Frame(pc)
-				fmt.Fprintf(st, "\n%+v", f)
-			}
-		}
-	}
-}
-
-func (s *stack) StackTrace() StackTrace {
-	f := make([]Frame, len(*s))
-	for i := 0; i < len(f); i++ {
-		f[i] = Frame((*s)[i])
-	}
-	return f
-}
-
-func callers() *stack {
-	const depth = 32
-	var pcs [depth]uintptr
-	n := runtime.Callers(3, pcs[:])
-	var st stack = pcs[0:n]
-	return &st
-}
-
-// funcname removes the path prefix component of a function's name reported by func.Name().
-func funcname(name string) string {
-	i := strings.LastIndex(name, "/")
-	name = name[i+1:]
-	i = strings.Index(name, ".")
-	return name[i+1:]
-}

vendor/github.com/uber/jaeger-client-go/.gitignore

@@ -1,15 +0,0 @@
-*.out
-*.test
-*.xml
-*.swp
-.idea/
-.tmp/
-*.iml
-*.cov
-*.html
-*.log
-gen/thrift/js
-gen/thrift/py
-vendor/
-crossdock-main
-crossdock/jaeger-docker-compose.yml

vendor/github.com/uber/jaeger-client-go/.gitmodules

@@ -1,3 +0,0 @@
-[submodule "idl"]
-	path = idl
-	url = https://github.com/uber/jaeger-idl.git

vendor/github.com/uber/jaeger-client-go/.travis.yml

@@ -1,56 +0,0 @@
-sudo: required
-
-language: go
-go_import_path: github.com/uber/jaeger-client-go
-
-dist: trusty
-
-matrix:
-  include:
-  # - go: 1.15.x
-  #   env:
-  #   - TESTS=true
-  #   - USE_DEP=true
-  #   - COVERAGE=true
-  - go: 1.15.x
-    env:
-    - USE_DEP=true
-    - CROSSDOCK=true
-  # - go: 1.15.x
-  #   env:
-  #   - TESTS=true
-  #   - USE_DEP=false
-  #   - USE_GLIDE=true
-  # test with previous version of Go
-  # - go: 1.14.x
-  #   env:
-  #   - TESTS=true
-  #   - USE_DEP=true
-  #   - CI_SKIP_LINT=true
-
-services:
-  - docker
-
-env:
-  global:
-    - DOCKER_COMPOSE_VERSION=1.8.0
-    - COMMIT=${TRAVIS_COMMIT::8}
-    # DOCKER_PASS
-    - secure: "CnjVyxNvMC/dhr/eR7C+FiWucZ4/O5LfAuz9YU0qlnV6XLR7XXRtzZlfFKIImJT6xHp+OptTqAIXqUbvwK2OXDP1ZsLiWRm+2elb9/isGusWXjs3g817lX8njSUcIFILbfi+vAE7UD2BKjHxpmvWmCZidisU1rcaZ9OQNPqMnNIDxVx0FOTwYx+2hfkdjnN5dikzafBDQ6ZZV/mGbcaTG45GGFU6DHyVLzf9qCPXyXnz2+VDhcoPQsYkzE56XHCmHxvEfXxgfqYefJNUlFPhniAQySVsCNVDJ8QcCV6uHaXoIzxJKx9FdUnWKI1/AtpQsTZPgEm4Ujnt+kGJsXopXy2Xx4MZxmcTCBwAMjZxPMF7KoojbtDeOZgEMtf1tGPN6DTNc3NpVmr0BKZ44lhqk+vnd8HAiC1tHDEoSb1Esl7dMUUf1qZAh3MtT+NYi3mTwyx/ilXUS7KPyy7x0ezB3kGuMoLhvR2hrprqRr5NOV2hrd1au+IXmb+4IanFOsBlceBfs8P0JFMO/aw15r+HimSZpQsJx//IT0LReCZYXLe0/WVsF/8+HDwHKlO99gGpk4iXlNKKvdPWabihMp3I3peMrvL+jnlwh47RqHs/0Q71xsKjVWTn+Svq3FpVP0Pgyxhg+oG4WEByBiLnBQcZwSBhWexkJrNI73GzaZiIldk="
-    # DOCKER_USER
-    - secure: "bpBSmypHzI4PnteM4cwLiMC2163Sj/4mEl+1dj+6NWl2tr1hREeVXKhsWBpah25n6BDyr2A4yhBZcWLaNKrsCKT3U37csAQTOFVeQ9x5xhPq+ohANd/OsspFsxNZaKwx161LizH/uTDotMxxevZacsyYWGNv/cRFkwcQ8upLkReRR6puJ+jNQC0BFpKWBJY/zpm5J7xFb7FO20LvQVyRgsgzqWmg9oRNVw9uwOfSY3btacftYctDLUbAr8YRNHd2C6dZnMAi8KdDTLXKTqjKmp6WidOmi92Ml7tOjB+bV6TOaVAhrcI5Rdje4rRWG4MucAjPMP0ZBW36KTfcGqFUcDhX7UqISe2WxoI+8ZD6fJ+nNtD3bk4YAUJB4BSs2sQdiYyjpHyGJR6RW50+3uRz2YbXpzVr9wqv2lZSl/xy3wC5Hag55uqzVlSiDw2pK8lctT3dnQveE7PqAI577PjF2NrHlgrBbykOwwUCNbRTmykzqoDnkxclmiZ+rflEeWsSYglePK/d6Gj9+N7wJZM5heprdJJMFTrzMWZ21Ll9ZGY9updCBKmJA8pBYiLHbu0lWOp+9QUGC+621Zq0d1PHhN6L4eXk/f3RNoZTr//cX6WdNmmO7tBbaGpmp/UYiYTY1WO9vP7tCDsT75k285HCfnIrlGRdbCZZbfuYNGPKIQ0="
-
-install:
-  - make install-ci USE_DEP=$USE_DEP
-  - if [ "$CROSSDOCK" == true ]; then bash ./travis/install-crossdock-deps.sh ; fi
-
-script:
-  - if [ "$TESTS" == true ]; then make test-ci ; else echo 'skipping tests'; fi
-  - if [ "$CROSSDOCK" == true ]; then bash ./travis/build-crossdock.sh ; else echo 'skipping crossdock'; fi
-
-after_success:
-  - if [ "$COVERAGE" == true ]; then mv cover.out coverage.txt ; else echo 'skipping coverage'; fi
-  - if [ "$COVERAGE" == true ]; then bash <(curl -s https://codecov.io/bash) ; else echo 'skipping coverage'; fi
-
-after_failure:
-  - if [ "$CROSSDOCK" == true ]; then timeout 5 docker-compose -f crossdock/docker-compose.yml logs; fi

vendor/github.com/uber/jaeger-client-go/CHANGELOG.md

@@ -1,396 +0,0 @@
-Changes by Version
-==================
-
-2.30.0 (2021-12-07)
--------------------
-- Add deprecation notice -- Yuri Shkuro
-- Use public struct for tracer options to document initialization better (#605) -- Yuri Shkuro
-- Remove redundant newline in NewReporter init message (#603) -- wwade
-- [zipkin] Encode span IDs as full 16-hex strings #601 -- Nathan
-- [docs] Replace godoc.org with pkg.go.dev (#591) -- Aaron Jheng
-- Remove outdated reference to Zipkin model. -- Yuri Shkuro
-- Move thrift compilation to a script (#590) -- Aaron Jheng
-- Document JAEGER_TRACEID_128BIT env var -- Yuri Shkuro
-
-2.29.1 (2021-05-24)
--------------------
-- Remove dependency on "testing" in "thrift" (#586) -- @yurishkuro
-
-
-2.29.0 (2021-05-20)
--------------------
-- Update vendored thrift to 0.14.1 (#584) -- @nhatthm
-
-
-2.28.0 (2021-04-30)
--------------------
-- HTTPSamplingStrategyFetcher: Use http client with 10 second timeout (#578) -- Joe Elliott
-
-
-2.27.0 (2021-04-19)
--------------------
-- Don't override HTTP Reporter batch size to 1; default to 100, user can override (#571) -- R. Aidan Campbell
-
-
-2.26.0 (2021-04-16)
--------------------
-- Delete a baggage item when value is blank (#562) -- evan.kim
-- Trim baggage key when parsing (#566) -- sicong.huang
-- feat: extend configuration to support custom randomNumber func (#555) -- NemoO_o
-- Support JAEGER_TRACEID_128BIT env var (#547) -- Yuri Shkuro
-- Additional context protections (#544) -- Joe Elliott
-- Lock RemotelyControlledSampler.sampler on callbacks (#543) -- Dima
-- Upgrade build to Go 1.15 (#539) -- Yuri Shkuro
-- Upgrade to jaeger-lib@2.3.0 to fix broken codahale/hdrhistogram dependency (#537) -- Yuri Shkuro
-- Prefix TraceID/SpanID.String() with zeroes (#533) -- Lukas Vogel
-- Upgrade to OpenTracing Go 1.2 (#525) -- Yuri Shkuro
-
-
-2.25.0 (2020-07-13)
--------------------
-## Breaking changes
-- [feat] Periodically re-resolve UDP server address, with opt-out (#520) -- Trevor Foster
-
-  The re-resolving of UDP address is now enabled by default, to make the client more robust in Kubernetes deployments.
-  The old resolve-once behavior can be restored by setting DisableAttemptReconnecting=true in the Configuration struct,
-  or via JAEGER_REPORTER_ATTEMPT_RECONNECTING_DISABLED=true environment variable.
-
-## Bug fixes
-- Do not add invalid context to references (#521) -- Yuri Shkuro
-
-
-2.24.0 (2020-06-14)
--------------------
-- Mention FromEnv() in the README, docs, and examples (#518) -- Martin Lercher
-- Serialize access to RemotelyControlledSampler.sampler (#515) -- Dima
-- Override reporter config only when agent host/port is set in env (#513) -- ilylia
-- Converge on JAEGER_SAMPLING_ENDPOINT env variable (#511) -- Eundoo Song
-
-
-2.23.1 (2020-04-28)
--------------------
-- Fix regression by handling nil logger correctly ([#507](https://github.com/jaegertracing/jaeger-client-go/pull/507)) -- Prithvi Raj
-
-
-2.23.0 (2020-04-22)
--------------------
-
-- Add the ability to log all span interactions at a new debug log level([#502](https://github.com/jaegertracing/jaeger-client-go/pull/502), [#503](https://github.com/jaegertracing/jaeger-client-go/pull/503), [#504](https://github.com/jaegertracing/jaeger-client-go/pull/504)) -- Prithvi Raj
-- Chore (docs): fix typos ([#496](https://github.com/jaegertracing/jaeger-client-go/pull/496), [#498](https://github.com/jaegertracing/jaeger-client-go/pull/498)) -- Febrian Setianto and Ivan Babrou
-- Unset highest bit of traceID in probabilistic sampler ([#490](https://github.com/jaegertracing/jaeger-client-go/pull/490)) -- Sokolov Yura
-
-2.22.1 (2020-01-16)
--------------------
-
-- Increase UDP batch overhead to account for data loss metrics ([#488](https://github.com/jaegertracing/jaeger-client-go/pull/488)) -- Yuri Shkuro
-
-
-2.22.0 (2020-01-15)
--------------------
-
-- Report data loss stats to Jaeger backend ([#482](https://github.com/jaegertracing/jaeger-client-go/pull/482)) -- Yuri Shkuro
-- Add limit on log records per span ([#483](https://github.com/jaegertracing/jaeger-client-go/pull/483)) -- Sokolov Yura
-
-
-2.21.1 (2019-12-20)
--------------------
-
-- Update version correctly.
-
-
-2.21.0 (2019-12-20)
--------------------
-
-- Clarify reporting error logs ([#469](https://github.com/jaegertracing/jaeger-client-go/pull/469)) -- Yuri Shkuro
-- Do not strip leading zeros from trace IDs ([#472](https://github.com/jaegertracing/jaeger-client-go/pull/472)) -- Yuri Shkuro
-- Chore (docs): fixed a couple of typos ([#475](https://github.com/jaegertracing/jaeger-client-go/pull/475)) -- Marc Bramaud
-- Support custom HTTP headers when reporting spans over HTTP ([#479](https://github.com/jaegertracing/jaeger-client-go/pull/479)) -- Albert Teoh
-
-
-2.20.1 (2019-11-08)
--------------------
-
-Minor patch via https://github.com/jaegertracing/jaeger-client-go/pull/468
-
-- Make `AdaptiveSamplerUpdater` usable with default values; Resolves #467
-- Create `OperationNameLateBinding` sampler option and config option
-- Make `SamplerOptions` var of public type, so that its functions are discoverable via godoc
-
-
-2.20.0 (2019-11-06)
--------------------
-
-## New Features
-
-- Allow all in-process spans of a trace to share sampling state (#443) -- Prithvi Raj
-
-  Sampling state is shared between all spans of the trace that are still in memory.
-  This allows implementation of delayed sampling decisions (see below).
-
-- Support delayed sampling decisions (#449) -- Yuri Shkuro
-
-  This is a large structural change to how the samplers work.
-  It allows some samplers to be executed multiple times on different
-  span events (like setting a tag) and make a positive sampling decision
-  later in the span life cycle, or even based on children spans.
-  See [README](./README.md#delayed-sampling) for more details.
-
-  There is a related minor change in behavior of the adaptive (per-operation) sampler,
-  which will no longer re-sample the trace when `span.SetOperation()` is called, i.e. the
-  operation used to make the sampling decision is always the one provided at span creation.
-
-- Add experimental tag matching sampler (#452) -- Yuri Shkuro
-
-  A sampler that can sample a trace based on a certain tag added to the root
-  span or one of its local (in-process) children. The sampler can be used with
-  another experimental `PrioritySampler` that allows multiple samplers to try
-  to make a sampling decision, in a certain priority order.
-
-- [log/zap] Report whether a trace was sampled (#445) -- Abhinav Gupta
-- Allow config.FromEnv() to enrich an existing config object (#436) -- Vineeth Reddy
-
-## Minor patches
-
-- Expose Sampler on Tracer and accept sampler options via Configuration (#460) -- Yuri Shkuro
-- Fix github.com/uber-go/atomic import (#464) -- Yuri Shkuro
-- Add nodejs to crossdock tests (#441) -- Bhavin Gandhi
-- Bump Go compiler version to 1.13 (#453) -- Yuri Shkuro
-
-2.19.0 (2019-09-23)
--------------------
-
-- Upgrade jaeger-lib to 2.2 and unpin Prom client (#434) -- Yuri Shkuro
-
-
-2.18.1 (2019-09-16)
--------------------
-
-- Remove go.mod / go.sum that interfere with `go get` (#432)
-
-
-2.18.0 (2019-09-09)
--------------------
-
-- Add option "noDebugFlagOnForcedSampling" for tracer initialization [resolves #422] (#423) <Jun Guo>
-
-
-2.17.0 (2019-08-30)
--------------------
-
-- Add a flag for firehose mode (#419) <Prithvi Raj>
-- Default sampling server URL to agent (#414) <Bryan Boreham>
-- Update default sampling rate when sampling strategy is refreshed (#413) <Bryan Boreham>
-- Support "Self" Span Reference (#411) <dm03514>
-- Don't complain about blank service name if tracing is Disabled (#410) Yuri <Shkuro>
-- Use IP address from tag if exist (#402) <NikoKVCS>
-- Expose span data to custom reporters [fixes #394] (#399) <Curtis Allen>
-- Fix the span allocation in the pool (#381) <Dmitry Ponomarev>
-
-
-2.16.0 (2019-03-24)
--------------------
-
-- Add baggage to B3 codec (#319) <Pavol Loffay>
-- Add support for 128bit trace ids to zipkin thrift spans. (#378) <Douglas Reid>
-- Update zipkin propagation logic to support 128bit traceIDs (#373) <Douglas Reid>
-- Accept "true" for the x-b3-sampled header (#356) <Adrian Bogatu>
-
-- Allow setting of PoolSpans from Config object (#322) <Matthew Pound>
-- Make propagators public to allow wrapping (#379) <Ivan Babrou>
-- Change default metric namespace to use relevant separator for the metric backend (#364) <Gary Brown>
-- Change metrics prefix to jaeger_tracer and add descriptions (#346) <Gary Brown>
-- Bump OpenTracing to ^1.1.x (#383) <Yuri Shkuro>
-- Upgrade jaeger-lib to v2.0.0 (#359) <Gary Brown>
-- Avoid defer when generating random number (#358) <Gary Brown>
-- Use a pool of rand.Source to reduce lock contention when creating span ids (#357) <Gary Brown>
-- Make JAEGER_ENDPOINT take priority over JAEGER_AGENT_XXX (#342) <Eundoo Song>
-
-
-2.15.0 (2018-10-10)
--------------------
-
-- Fix FollowsFrom spans ignoring baggage/debug header from dummy parent context (#313) <Zvi Cahana>
-- Make maximum annotation length configurable in tracer options (#318) <Eric Chang>
-- Support more environment variables in configuration (#323) <Daneyon Hansen>
-- Print error on Sampler Query failure (#328) <Goutham Veeramachaneni>
-- Add an HTTPOption to support custom http.RoundTripper (#333) <Michael Puncel>
-- Return an error when an HTTP error code is seen in zipkin HTTP transport (#331) <Michael Puncel>
-
-
-2.14.0 (2018-04-30)
--------------------
-
-- Support throttling for debug traces (#274) <Isaac Hier>
-- Remove dependency on Apache Thrift (#303) <Yuri Shkuro>
-- Remove dependency on tchannel  (#295) (#294) <Yuri Shkuro>
-- Test with Go 1.9 (#298) <Yuri Shkuro>
-
-
-2.13.0 (2018-04-15)
--------------------
-
-- Use value receiver for config.NewTracer() (#283) <Yuri Shkuro>
-- Lock span during jaeger thrift conversion (#273) <Won Jun Jang>
-- Fix the RemotelyControlledSampler so that it terminates go-routine on Close() (#260) <Scott Kidder> <Yuri Shkuro>
-- Added support for client configuration via env vars (#275) <Juraci Paixão Kröhling>
-- Allow overriding sampler in the Config (#270) <Mike Kabischev>
-
-
-2.12.0 (2018-03-14)
--------------------
-
-- Use lock when retrieving span.Context() (#268)
-- Add Configuration support for custom Injector and Extractor (#263) <Martin Liu>
-
-
-2.11.2 (2018-01-12)
--------------------
-
-- Add Gopkg.toml to allow using the lib with `dep`
-
-
-2.11.1 (2018-01-03)
--------------------
-
-- Do not enqueue spans after Reporter is closed (#235, #245)
-- Change default flush interval to 1sec (#243)
-
-
-2.11.0 (2017-11-27)
--------------------
-
-- Normalize metric names and tags to be compatible with Prometheus (#222)
-
-
-2.10.0 (2017-11-14)
--------------------
-
-- Support custom tracing headers (#176)
-- Add BaggageRestrictionManager (#178) and RemoteBaggageRestrictionManager (#182)
-- Do not coerce baggage keys to lower case (#196)
-- Log span name when span cannot be reported (#198)
-- Add option to enable gen128Bit for tracer (#193) and allow custom generator for high bits of trace ID (#219)
-
-
-2.9.0 (2017-07-29)
-------------------
-
-- Pin thrift <= 0.10 (#179)
-- Introduce a parallel interface ContribObserver (#159)
-
-
-2.8.0 (2017-07-05)
-------------------
-
-- Drop `jaeger.` prefix from `jaeger.hostname` process-level tag
-- Add options to set tracer tags
-
-
-2.7.0 (2017-06-21)
-------------------
-
-- Fix rate limiter balance [#135](https://github.com/uber/jaeger-client-go/pull/135) [#140](https://github.com/uber/jaeger-client-go/pull/140)
-- Default client to send Jaeger.thrift [#147](https://github.com/uber/jaeger-client-go/pull/147)
-- Save baggage in span [#153](https://github.com/uber/jaeger-client-go/pull/153)
-- Move reporter.queueLength to the top of the struct to guarantee 64bit alignment [#158](https://github.com/uber/jaeger-client-go/pull/158)
-- Support HTTP transport with jaeger.thrift [#161](https://github.com/uber/jaeger-client-go/pull/161)
-
-
-2.6.0 (2017-03-28)
-------------------
-
-- Add config option to initialize RPC Metrics feature
-
-
-2.5.0 (2017-03-23)
-------------------
-
-- Split request latency metric by success/failure [#123](https://github.com/uber/jaeger-client-go/pull/123)
-- Add mutex to adaptive sampler and fix race condition [#124](https://github.com/uber/jaeger-client-go/pull/124)
-- Fix rate limiter panic [#125](https://github.com/uber/jaeger-client-go/pull/125)
-
-
-2.4.0 (2017-03-21)
-------------------
-
-- Remove `_ms` suffix from request latency metric name [#121](https://github.com/uber/jaeger-client-go/pull/121)
-- Rename all metrics to "request" and "http_request" and use tags for other dimensions [#121](https://github.com/uber/jaeger-client-go/pull/121)
-
-
-2.3.0 (2017-03-20)
-------------------
-
-- Make Span type public to allow access to non-std methods for testing [#117](https://github.com/uber/jaeger-client-go/pull/117)
-- Add a structured way to extract traces for logging with zap [#118](https://github.com/uber/jaeger-client-go/pull/118)
-
-
-2.2.1 (2017-03-14)
-------------------
-
-- Fix panic caused by updating the remote sampler from adaptive sampler to any other sampler type (https://github.com/uber/jaeger-client-go/pull/111)
-
-
-2.2.0 (2017-03-10)
-------------------
-
-- Introduce Observer and SpanObserver (https://github.com/uber/jaeger-client-go/pull/94)
-- Add RPC metrics emitter as Observer/SpanObserver (https://github.com/uber/jaeger-client-go/pull/103)
-
-
-2.1.2 (2017-02-27)
--------------------
-
-- Fix leaky bucket bug (https://github.com/uber/jaeger-client-go/pull/99)
-- Fix zap logger Infof (https://github.com/uber/jaeger-client-go/pull/100)
-- Add tracer initialization godoc examples
-
-
-2.1.1 (2017-02-21)
--------------------
-
-- Fix inefficient usage of zap.Logger
-
-
-2.1.0 (2017-02-17)
--------------------
-
-- Add adapter for zap.Logger (https://github.com/uber-go/zap)
-- Move logging API to ./log/ package
-
-
-2.0.0 (2017-02-08)
--------------------
-
-- Support Adaptive Sampling
-- Support 128bit Trace IDs
-- Change trace/span IDs from uint64 to strong types TraceID and SpanID
-- Add Zipkin HTTP B3 Propagation format support #72
-- Rip out existing metrics and use github.com/uber/jaeger-lib/metrics
-- Change API for tracer, reporter, sampler initialization
-
-
-1.6.0 (2016-10-14)
--------------------
-
-- Add Zipkin HTTP transport
-- Support external baggage via jaeger-baggage header
-- Unpin Thrift version, keep to master
-
-
-1.5.1 (2016-09-27)
--------------------
-
-- Relax dependency on opentracing to ^1
-
-
-1.5.0 (2016-09-27)
--------------------
-
-- Upgrade to opentracing-go 1.0
-- Support KV logging for Spans
-
-
-1.4.0 (2016-09-14)
--------------------
-
-- Support debug traces via HTTP header "jaeger-debug-id"

vendor/github.com/uber/jaeger-client-go/CODEOWNERS

@@ -1,2 +0,0 @@
-
-* @jaegertracing/jaeger-maintainers

vendor/github.com/uber/jaeger-client-go/CONTRIBUTING.md

@@ -1,170 +0,0 @@
-# How to Contribute to Jaeger
-
-We'd love your help!
-
-Jaeger is [Apache 2.0 licensed](LICENSE) and accepts contributions via GitHub
-pull requests. This document outlines some of the conventions on development
-workflow, commit message formatting, contact points and other resources to make
-it easier to get your contribution accepted.
-
-We gratefully welcome improvements to documentation as well as to code.
-
-# Certificate of Origin
-
-By contributing to this project you agree to the [Developer Certificate of
-Origin](https://developercertificate.org/) (DCO). This document was created
-by the Linux Kernel community and is a simple statement that you, as a
-contributor, have the legal right to make the contribution. See the [DCO](DCO)
-file for details.
-
-## Getting Started
-
-This library uses [dep](https://golang.github.io/dep/) to manage dependencies.
-
-To get started, make sure you clone the Git repository into the correct location
-`github.com/uber/jaeger-client-go` relative to `$GOPATH`:
-
-```
-mkdir -p $GOPATH/src/github.com/uber
-cd $GOPATH/src/github.com/uber
-git clone git@github.com:jaegertracing/jaeger-client-go.git jaeger-client-go
-cd jaeger-client-go
-git submodule update --init --recursive
-```
-
-Then install dependencies and run the tests:
-
-```
-make install
-make test
-```
-
-## Imports grouping
-
-This projects follows the following pattern for grouping imports in Go files:
-  * imports from standard library
-  * imports from other projects
-  * imports from `jaeger-client-go` project
-
-For example:
-
-```go
-import (
-	"fmt"
-
-	"github.com/uber/jaeger-lib/metrics"
-	"go.uber.org/zap"
-
-	"github.com/uber/jaeger-client-go/config"
-)
-```
-
-## Making A Change
-
-*Before making any significant changes, please [open an
-issue](https://github.com/jaegertracing/jaeger-client-go/issues).* Discussing your proposed
-changes ahead of time will make the contribution process smooth for everyone.
-
-Once we've discussed your changes and you've got your code ready, make sure
-that tests are passing (`make test` or `make cover`) and open your PR. Your
-pull request is most likely to be accepted if it:
-
-* Includes tests for new functionality.
-* Follows the guidelines in [Effective
-  Go](https://golang.org/doc/effective_go.html) and the [Go team's common code
-  review comments](https://github.com/golang/go/wiki/CodeReviewComments).
-* Has a [good commit message](https://chris.beams.io/posts/git-commit/):
-   * Separate subject from body with a blank line
-   * Limit the subject line to 50 characters
-   * Capitalize the subject line
-   * Do not end the subject line with a period
-   * Use the imperative mood in the subject line
-   * Wrap the body at 72 characters
-   * Use the body to explain _what_ and _why_ instead of _how_
-* Each commit must be signed by the author ([see below](#sign-your-work)).
-
-## License
-
-By contributing your code, you agree to license your contribution under the terms
-of the [Apache License](LICENSE).
-
-If you are adding a new file it should have a header like below.  The easiest
-way to add such header is to run `make fmt`.
-
-```
-// Copyright (c) 2017 The Jaeger 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.
-```
-
-## Sign your work
-
-The sign-off is a simple line at the end of the explanation for the
-patch, which certifies that you wrote it or otherwise have the right to
-pass it on as an open-source patch.  The rules are pretty simple: if you
-can certify the below (from
-[developercertificate.org](http://developercertificate.org/)):
-
-```
-Developer Certificate of Origin
-Version 1.1
-
-Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-660 York Street, Suite 102,
-San Francisco, CA 94110 USA
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.
-```
-
-then you just add a line to every git commit message:
-
-    Signed-off-by: Joe Smith <joe@gmail.com>
-
-using your real name (sorry, no pseudonyms or anonymous contributions.)
-
-You can add the sign off when creating the git commit via `git commit -s`.
-
-If you want this to be automatic you can set up some aliases:
-
-```
-git config --add alias.amend "commit -s --amend"
-git config --add alias.c "commit -s"
-```

vendor/github.com/uber/jaeger-client-go/DCO

@@ -1,37 +0,0 @@
-Developer Certificate of Origin
-Version 1.1
-
-Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
-660 York Street, Suite 102,
-San Francisco, CA 94110 USA
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-
-Developer's Certificate of Origin 1.1
-
-By making a contribution to this project, I certify that:
-
-(a) The contribution was created in whole or in part by me and I
-    have the right to submit it under the open source license
-    indicated in the file; or
-
-(b) The contribution is based upon previous work that, to the best
-    of my knowledge, is covered under an appropriate open source
-    license and I have the right under that license to submit that
-    work with modifications, whether created in whole or in part
-    by me, under the same open source license (unless I am
-    permitted to submit under a different license), as indicated
-    in the file; or
-
-(c) The contribution was provided directly to me by some other
-    person who certified (a), (b) or (c) and I have not modified
-    it.
-
-(d) I understand and agree that this project and the contribution
-    are public and that a record of the contribution (including all
-    personal information I submit with it, including my sign-off) is
-    maintained indefinitely and may be redistributed consistent with
-    this project or the open source license(s) involved.
-

vendor/github.com/uber/jaeger-client-go/Gopkg.lock

@@ -1,301 +0,0 @@
-# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
-
-
-[[projects]]
-  digest = "1:4c4c33075b704791d6a7f09dfb55c66769e8a1dc6adf87026292d274fe8ad113"
-  name = "github.com/HdrHistogram/hdrhistogram-go"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "3a0bb77429bd3a61596f5e8a3172445844342120"
-  version = "0.9.0"
-
-[[projects]]
-  digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d"
-  name = "github.com/beorn7/perks"
-  packages = ["quantile"]
-  pruneopts = "UT"
-  revision = "37c8de3658fcb183f997c4e13e8337516ab753e6"
-  version = "v1.0.1"
-
-[[projects]]
-  branch = "master"
-  digest = "1:a382acd6150713655ded76ab5fbcbc7924a7808dab4312dda5d1f23dd8ce5277"
-  name = "github.com/crossdock/crossdock-go"
-  packages = [
-    ".",
-    "assert",
-    "require",
-  ]
-  pruneopts = "UT"
-  revision = "049aabb0122b03bc9bd30cab8f3f91fb60166361"
-
-[[projects]]
-  digest = "1:ffe9824d294da03b391f44e1ae8281281b4afc1bdaa9588c9097785e3af10cec"
-  name = "github.com/davecgh/go-spew"
-  packages = ["spew"]
-  pruneopts = "UT"
-  revision = "8991bc29aa16c548c550c7ff78260e27b9ab7c73"
-  version = "v1.1.1"
-
-[[projects]]
-  digest = "1:7ae311278f7ccaa724de8f2cdec0a507ba3ee6dea8c77237e8157bcf64b0f28b"
-  name = "github.com/golang/mock"
-  packages = ["gomock"]
-  pruneopts = "UT"
-  revision = "f7b1909c82a8958747e5c87c6a5c3b2eaed8a33d"
-  version = "v1.4.4"
-
-[[projects]]
-  digest = "1:4a32eb57407190eced21a21abee9ce4d4ab6f0bf113ca61cb1cb2d549a65c985"
-  name = "github.com/golang/protobuf"
-  packages = [
-    "proto",
-    "ptypes",
-    "ptypes/any",
-    "ptypes/duration",
-    "ptypes/timestamp",
-  ]
-  pruneopts = "UT"
-  revision = "d04d7b157bb510b1e0c10132224b616ac0e26b17"
-  version = "v1.4.2"
-
-[[projects]]
-  digest = "1:ff5ebae34cfbf047d505ee150de27e60570e8c394b3b8fdbb720ff6ac71985fc"
-  name = "github.com/matttproud/golang_protobuf_extensions"
-  packages = ["pbutil"]
-  pruneopts = "UT"
-  revision = "c12348ce28de40eed0136aa2b644d0ee0650e56c"
-  version = "v1.0.1"
-
-[[projects]]
-  digest = "1:fe5217d44ae8fb84f711968816fe50077cea9dfa8f44425b8e44e7e3de896d01"
-  name = "github.com/opentracing/opentracing-go"
-  packages = [
-    ".",
-    "ext",
-    "harness",
-    "log",
-  ]
-  pruneopts = "UT"
-  revision = "d34af3eaa63c4d08ab54863a4bdd0daa45212e12"
-  version = "v1.2.0"
-
-[[projects]]
-  digest = "1:9e1d37b58d17113ec3cb5608ac0382313c5b59470b94ed97d0976e69c7022314"
-  name = "github.com/pkg/errors"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "614d223910a179a466c1767a985424175c39b465"
-  version = "v0.9.1"
-
-[[projects]]
-  digest = "1:0028cb19b2e4c3112225cd871870f2d9cf49b9b4276531f03438a88e94be86fe"
-  name = "github.com/pmezard/go-difflib"
-  packages = ["difflib"]
-  pruneopts = "UT"
-  revision = "792786c7400a136282c1664665ae0a8db921c6c2"
-  version = "v1.0.0"
-
-[[projects]]
-  digest = "1:7097829edd12fd7211fca0d29496b44f94ef9e6d72f88fb64f3d7b06315818ad"
-  name = "github.com/prometheus/client_golang"
-  packages = [
-    "prometheus",
-    "prometheus/internal",
-  ]
-  pruneopts = "UT"
-  revision = "170205fb58decfd011f1550d4cfb737230d7ae4f"
-  version = "v1.1.0"
-
-[[projects]]
-  digest = "1:0db23933b8052702d980a3f029149b3f175f7c0eea0cff85b175017d0f2722c0"
-  name = "github.com/prometheus/client_model"
-  packages = ["go"]
-  pruneopts = "UT"
-  revision = "7bc5445566f0fe75b15de23e6b93886e982d7bf9"
-  version = "v0.2.0"
-
-[[projects]]
-  digest = "1:4407525bde4e6ad9c1f60113d38cbb255d769e0ea506c8cf877db39da7753b3a"
-  name = "github.com/prometheus/common"
-  packages = [
-    "expfmt",
-    "internal/bitbucket.org/ww/goautoneg",
-    "model",
-  ]
-  pruneopts = "UT"
-  revision = "317b7b125e8fddda956d0c9574e5f03f438ed5bc"
-  version = "v0.14.0"
-
-[[projects]]
-  digest = "1:b2268435af85ee1a0fca0e37de4225f78e2d9d8b0b66acde3a29f127634efa87"
-  name = "github.com/prometheus/procfs"
-  packages = [
-    ".",
-    "internal/fs",
-    "internal/util",
-  ]
-  pruneopts = "UT"
-  revision = "9dece15c53cd5e9fbfbd72d5108adcf526a3f486"
-  version = "v0.2.0"
-
-[[projects]]
-  digest = "1:86ff4af7b6bb3d27c2e89b5ef8c139678acff1cad74a3c5235fc5af6b94fcc9e"
-  name = "github.com/stretchr/objx"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "35313a95ee26395aa17d366c71a2ccf788fa69b6"
-  version = "v0.3.0"
-
-[[projects]]
-  digest = "1:5201127841a78d84d0ca68a2e564c08e3882c0fb9321a75997ce87926e0d63ea"
-  name = "github.com/stretchr/testify"
-  packages = [
-    "assert",
-    "mock",
-    "require",
-    "suite",
-  ]
-  pruneopts = "UT"
-  revision = "f654a9112bbeac49ca2cd45bfbe11533c4666cf8"
-  version = "v1.6.1"
-
-[[projects]]
-  digest = "1:4af46f2faea30e52c96ec9ec32bb654d2729579a80d242b0acfa193ad321eb61"
-  name = "github.com/uber/jaeger-lib"
-  packages = [
-    "metrics",
-    "metrics/metricstest",
-    "metrics/prometheus",
-  ]
-  pruneopts = "UT"
-  revision = "48cc1df63e6be0d63b95677f0d22beb880bce1e4"
-  version = "v2.3.0"
-
-[[projects]]
-  digest = "1:7a3de4371d6b68c6f37a0df2c09905664d9de59026c91cbe275aae55f4fe760f"
-  name = "go.uber.org/atomic"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "12f27ba2637fa0e13772a4f05fa46a5d18d53182"
-  version = "v1.7.0"
-
-[[projects]]
-  digest = "1:e9eeeabfd025a5e69b9c8e2857d3517ea67e747ae913bcb0a9e1e7bafdb9c298"
-  name = "go.uber.org/multierr"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "3114a8b704d2d28dbacda34a872690aaef66aeed"
-  version = "v1.6.0"
-
-[[projects]]
-  digest = "1:0398f5f0e2e9233f25fad702f3b323241daf9f876cc869ab259238cf1bced236"
-  name = "go.uber.org/zap"
-  packages = [
-    ".",
-    "buffer",
-    "internal/bufferpool",
-    "internal/color",
-    "internal/exit",
-    "zapcore",
-    "zaptest/observer",
-  ]
-  pruneopts = "UT"
-  revision = "404189cf44aea95b0cd9bddcb0242dd4cf88c510"
-  version = "v1.16.0"
-
-[[projects]]
-  branch = "master"
-  digest = "1:f8b491a7c25030a895a0e579742d07136e6958e77ef2d46e769db8eec4e58fcd"
-  name = "golang.org/x/net"
-  packages = [
-    "context",
-    "context/ctxhttp",
-  ]
-  pruneopts = "UT"
-  revision = "328152dc79b1547da63f950cd4cdd9afd50b2774"
-
-[[projects]]
-  branch = "master"
-  digest = "1:1e581fa394685ef0d84008ae04cf3414390c1a700c04846853869cb4ac2fec86"
-  name = "golang.org/x/sys"
-  packages = [
-    "internal/unsafeheader",
-    "unix",
-    "windows",
-  ]
-  pruneopts = "UT"
-  revision = "d9f96fdee20d1e5115ee34ba4016eae6cfb66eb9"
-
-[[projects]]
-  digest = "1:fd328c5b52e433ea3ffc891bcc4f94469a82bf478558208db2b386aad8a304a1"
-  name = "google.golang.org/protobuf"
-  packages = [
-    "encoding/prototext",
-    "encoding/protowire",
-    "internal/descfmt",
-    "internal/descopts",
-    "internal/detrand",
-    "internal/encoding/defval",
-    "internal/encoding/messageset",
-    "internal/encoding/tag",
-    "internal/encoding/text",
-    "internal/errors",
-    "internal/fieldsort",
-    "internal/filedesc",
-    "internal/filetype",
-    "internal/flags",
-    "internal/genid",
-    "internal/impl",
-    "internal/mapsort",
-    "internal/pragma",
-    "internal/set",
-    "internal/strs",
-    "internal/version",
-    "proto",
-    "reflect/protoreflect",
-    "reflect/protoregistry",
-    "runtime/protoiface",
-    "runtime/protoimpl",
-    "types/known/anypb",
-    "types/known/durationpb",
-    "types/known/timestamppb",
-  ]
-  pruneopts = "UT"
-  revision = "3f7a61f89bb6813f89d981d1870ed68da0b3c3f1"
-  version = "v1.25.0"
-
-[[projects]]
-  branch = "v3"
-  digest = "1:229cb0f6192914f518cc1241ede6d6f1f458b31debfa18bf3a5c9e4f7b01e24b"
-  name = "gopkg.in/yaml.v3"
-  packages = ["."]
-  pruneopts = "UT"
-  revision = "eeeca48fe7764f320e4870d231902bf9c1be2c08"
-
-[solve-meta]
-  analyzer-name = "dep"
-  analyzer-version = 1
-  input-imports = [
-    "github.com/crossdock/crossdock-go",
-    "github.com/golang/mock/gomock",
-    "github.com/opentracing/opentracing-go",
-    "github.com/opentracing/opentracing-go/ext",
-    "github.com/opentracing/opentracing-go/harness",
-    "github.com/opentracing/opentracing-go/log",
-    "github.com/pkg/errors",
-    "github.com/prometheus/client_golang/prometheus",
-    "github.com/stretchr/testify/assert",
-    "github.com/stretchr/testify/mock",
-    "github.com/stretchr/testify/require",
-    "github.com/stretchr/testify/suite",
-    "github.com/uber/jaeger-lib/metrics",
-    "github.com/uber/jaeger-lib/metrics/metricstest",
-    "github.com/uber/jaeger-lib/metrics/prometheus",
-    "go.uber.org/atomic",
-    "go.uber.org/zap",
-    "go.uber.org/zap/zapcore",
-    "go.uber.org/zap/zaptest/observer",
-  ]
-  solver-name = "gps-cdcl"
-  solver-version = 1

vendor/github.com/uber/jaeger-client-go/Gopkg.toml

@@ -1,31 +0,0 @@
-[[constraint]]
-  name = "github.com/crossdock/crossdock-go"
-  branch = "master"
-
-[[constraint]]
-  name = "github.com/opentracing/opentracing-go"
-  version = "^1.2"
-
-[[constraint]]
-  name = "github.com/prometheus/client_golang"
-  version = "^1"
-
-[[constraint]]
-  name = "github.com/stretchr/testify"
-  version = "^1.1.3"
-
-[[constraint]]
-  name = "go.uber.org/atomic"
-  version = "^1"
-
-[[constraint]]
-  name = "github.com/uber/jaeger-lib"
-  version = "^2.3"
-
-[[constraint]]
-  name = "go.uber.org/zap"
-  version = "^1"
-
-[prune]
-  go-tests = true
-  unused-packages = true

vendor/github.com/uber/jaeger-client-go/Makefile

@@ -1,135 +0,0 @@
-PROJECT_ROOT=github.com/uber/jaeger-client-go
-export GO111MODULE=off
-PACKAGES := . $(shell GO111MODULE=off go list ./... | awk -F/ 'NR>1 {print "./"$$4"/..."}' | grep -v -e ./thrift-gen/... -e ./thrift/... | sort -u)
-# all .go files that don't exist in hidden directories
-ALL_SRC := $(shell find . -name "*.go" | grep -v -e vendor -e thrift-gen -e ./thrift/ \
-        -e ".*/\..*" \
-        -e ".*/_.*" \
-        -e ".*/mocks.*")
-
-USE_DEP := true
-
--include crossdock/rules.mk
-
-RACE=-race
-GOTEST=go test -v $(RACE)
-GOLINT=golint
-GOVET=go vet
-GOFMT=gofmt
-FMT_LOG=fmt.log
-LINT_LOG=lint.log
-
-THRIFT_VER=0.14
-THRIFT_IMG=jaegertracing/thrift:$(THRIFT_VER)
-THRIFT=docker run -v "${PWD}:/data" -u ${shell id -u}:${shell id -g} $(THRIFT_IMG) thrift
-
-PASS=$(shell printf "\033[32mPASS\033[0m")
-FAIL=$(shell printf "\033[31mFAIL\033[0m")
-COLORIZE=sed ''/PASS/s//$(PASS)/'' | sed ''/FAIL/s//$(FAIL)/''
-
-.DEFAULT_GOAL := test-and-lint
-
-.PHONY: test-and-lint
-test-and-lint: test fmt lint
-
-.PHONY: test
-test:
-ifeq ($(USE_DEP),true)
-	dep check
-endif
-	bash -c "set -e; set -o pipefail; $(GOTEST) $(PACKAGES) | $(COLORIZE)"
-
-.PHONY: fmt
-fmt:
-	$(GOFMT) -e -s -l -w $(ALL_SRC)
-	./scripts/updateLicenses.sh
-
-.PHONY: lint
-lint: vet golint lint-fmt lint-thrift-testing
-
-.PHONY: vet
-vet:
-	$(GOVET) $(PACKAGES)
-
-.PHONY: golint
-golint:
-	@cat /dev/null > $(LINT_LOG)
-	@$(foreach pkg, $(PACKAGES), $(GOLINT) $(pkg) | grep -v crossdock/thrift >> $(LINT_LOG) || true;)
-	@[ ! -s "$(LINT_LOG)" ] || (echo "Lint Failures" | cat - $(LINT_LOG) && false)
-
-.PHONY: lint-fmt
-lint-fmt:
-	@$(GOFMT) -e -s -l $(ALL_SRC) > $(FMT_LOG)
-	./scripts/updateLicenses.sh >> $(FMT_LOG)
-	@[ ! -s "$(FMT_LOG)" ] || (echo "go fmt or license check failures, run 'make fmt'" | cat - $(FMT_LOG) && false)
-
-# make sure thrift/ module does not import "testing"
-.PHONY: lint-thrift-testing
-lint-thrift-testing:
-	@cat /dev/null > $(LINT_LOG)
-	@(grep -rn '"testing"' thrift | grep -v README.md > $(LINT_LOG)) || true
-	@[ ! -s "$(LINT_LOG)" ] || (echo '"thrift" module must not import "testing", see issue #585' | cat - $(LINT_LOG) && false)
-
-.PHONY: install
-install:
-	@echo install: USE_DEP=$(USE_DEP) USE_GLIDE=$(USE_GLIDE)
-ifeq ($(USE_DEP),true)
-	dep version || make install-dep
-	dep ensure -vendor-only -v
-endif
-ifeq ($(USE_GLIDE),true)
-	glide --version || go get github.com/Masterminds/glide
-	glide install
-endif
-
-
-.PHONY: cover
-cover:
-	$(GOTEST) -cover -coverprofile cover.out $(PACKAGES)
-
-.PHONY: cover-html
-cover-html: cover
-	go tool cover -html=cover.out -o cover.html
-
-# This is not part of the regular test target because we don't want to slow it
-# down.
-.PHONY: test-examples
-test-examples:
-	make -C examples
-
-.PHONY: thrift
-thrift: idl-submodule thrift-compile
-
-# TODO at the moment we're not generating tchan_*.go files
-.PHONY: thrift-compile
-thrift-compile: thrift-image
-	docker run -v "${PWD}:/data" -u ${shell id -u}:${shell id -g} $(THRIFT_IMG) /data/scripts/gen-thrift.sh
-
-.PHONY: idl-submodule
-idl-submodule:
-	git submodule init
-	git submodule update
-
-.PHONY: thrift-image
-thrift-image:
-	$(THRIFT) -version
-
-.PHONY: install-dep
-install-dep:
-	- curl -L -s https://github.com/golang/dep/releases/download/v0.5.0/dep-linux-amd64 -o $$GOPATH/bin/dep
-	- chmod +x $$GOPATH/bin/dep
-
-.PHONY: install-ci
-install-ci: install
-	go get github.com/wadey/gocovmerge
-	go get github.com/mattn/goveralls
-	go get golang.org/x/tools/cmd/cover
-	go get golang.org/x/lint/golint
-
-.PHONY: test-ci
-test-ci: cover
-ifeq ($(CI_SKIP_LINT),true)
-	echo 'skipping lint'
-else
-	make lint
-endif

vendor/github.com/uber/jaeger-client-go/README.md

@@ -1,339 +0,0 @@
-[![GoDoc][doc-img]][doc] [![Build Status][ci-img]][ci] [![Coverage Status][cov-img]][cov] [![OpenTracing 1.0 Enabled][ot-img]][ot-url]
-
-# 🛑 This library is being deprecated!
-
-We urge all users to migrate to [OpenTelemetry](https://opentelemetry.io/). Please refer to the [notice in the documentation](https://www.jaegertracing.io/docs/latest/client-libraries/#deprecating-jaeger-clients) for details.
-
-# Jaeger Bindings for Go OpenTracing API
-
-Instrumentation library that implements an
-[OpenTracing Go](https://github.com/opentracing/opentracing-go) Tracer for Jaeger (https://jaegertracing.io).
-
-**IMPORTANT**: The library's import path is based on its original location under `github.com/uber`. Do not try to import it as `github.com/jaegertracing`, it will not compile. We might revisit this in the next major release.
-  * :white_check_mark: `import "github.com/uber/jaeger-client-go"`
-  * :x: `import "github.com/jaegertracing/jaeger-client-go"`
-
-## How to Contribute
-
-Please see [CONTRIBUTING.md](CONTRIBUTING.md).
-
-## Installation
-
-### Preferred
-
-Add `github.com/uber/jaeger-client-go` to `go.mod`.
-
-### Old way
-
-We recommended using a dependency manager like [dep](https://golang.github.io/dep/)
-and [semantic versioning](http://semver.org/) when including this library into an application.
-For example, Jaeger backend imports this library like this:
-
-```toml
-[[constraint]]
-  name = "github.com/uber/jaeger-client-go"
-  version = "2.17"
-```
-
-If you instead want to use the latest version in `master`, you can pull it via `go get`.
-Note that during `go get` you may see build errors due to incompatible dependencies, which is why
-we recommend using semantic versions for dependencies.  The error  may be fixed by running
-`make install` (it will install `dep` if you don't have it):
-
-```shell
-go get -u github.com/uber/jaeger-client-go/
-cd $GOPATH/src/github.com/uber/jaeger-client-go/
-git submodule update --init --recursive
-make install
-```
-
-## Initialization
-
-See tracer initialization examples in [godoc](https://pkg.go.dev/github.com/uber/jaeger-client-go/config#pkg-examples)
-and [config/example_test.go](./config/example_test.go).
-
-There are two ways to create a tracer:
-  * Using [Configuration](https://pkg.go.dev/github.com/uber/jaeger-client-go/config#Configuration) struct that allows declarative configuration. For example, you can populate that struct from a YAML/JSON config, or ask it to initialize itself using environment variables (see next section).
-  * Using [NewTracer()](https://pkg.go.dev/github.com/uber/jaeger-client-go#NewTracer) function that allows for full programmatic control of configuring the tracer using TracerOptions.
-
-### Environment variables
-
-The tracer can be initialized with values coming from environment variables, if it is
-[built from a config](https://pkg.go.dev/github.com/uber/jaeger-client-go/config?tab=doc#Configuration.NewTracer)
-that was created via [FromEnv()](https://pkg.go.dev/github.com/uber/jaeger-client-go/config?tab=doc#FromEnv).
-None of the env vars are required and all of them can be overridden via direct setting
-of the property on the configuration object.
-
-Property| Description
---- | ---
-JAEGER_SERVICE_NAME | The service name.
-JAEGER_AGENT_HOST | The hostname for communicating with agent via UDP (default `localhost`).
-JAEGER_AGENT_PORT | The port for communicating with agent via UDP (default `6831`).
-JAEGER_ENDPOINT | The HTTP endpoint for sending spans directly to a collector, i.e. http://jaeger-collector:14268/api/traces. If specified, the agent host/port are ignored.
-JAEGER_USER | Username to send as part of "Basic" authentication to the collector endpoint.
-JAEGER_PASSWORD | Password to send as part of "Basic" authentication to the collector endpoint.
-JAEGER_REPORTER_LOG_SPANS | Whether the reporter should also log the spans" `true` or `false` (default `false`).
-JAEGER_REPORTER_MAX_QUEUE_SIZE | The reporter's maximum queue size (default `100`).
-JAEGER_REPORTER_FLUSH_INTERVAL | The reporter's flush interval, with units, e.g. `500ms` or `2s` ([valid units][timeunits]; default `1s`).
-JAEGER_REPORTER_ATTEMPT_RECONNECTING_DISABLED | When true, disables udp connection helper that periodically re-resolves the agent's hostname and reconnects if there was a change (default `false`).
-JAEGER_REPORTER_ATTEMPT_RECONNECT_INTERVAL | Controls how often the agent client re-resolves the provided hostname in order to detect address changes ([valid units][timeunits]; default `30s`).
-JAEGER_SAMPLER_TYPE | The sampler type: `remote`, `const`, `probabilistic`, `ratelimiting` (default `remote`). See also https://www.jaegertracing.io/docs/latest/sampling/.
-JAEGER_SAMPLER_PARAM | The sampler parameter (number).
-JAEGER_SAMPLER_MANAGER_HOST_PORT | (deprecated) The HTTP endpoint when using the `remote` sampler.
-JAEGER_SAMPLING_ENDPOINT | The URL for the sampling configuration server when using sampler type `remote` (default `http://127.0.0.1:5778/sampling`).
-JAEGER_SAMPLER_MAX_OPERATIONS | The maximum number of operations that the sampler will keep track of (default `2000`).
-JAEGER_SAMPLER_REFRESH_INTERVAL | How often the `remote` sampler should poll the configuration server for the appropriate sampling strategy, e.g. "1m" or "30s" ([valid units][timeunits]; default `1m`).
-JAEGER_TAGS | A comma separated list of `name=value` tracer-level tags, which get added to all reported spans. The value can also refer to an environment variable using the format `${envVarName:defaultValue}`.
-JAEGER_TRACEID_128BIT | Whether to enable 128bit trace-id generation, `true` or `false`. If not enabled, the SDK defaults to 64bit trace-ids.
-JAEGER_DISABLED | Whether the tracer is disabled or not. If `true`, the `opentracing.NoopTracer` is used (default `false`).
-JAEGER_RPC_METRICS | Whether to store RPC metrics, `true` or `false` (default `false`).
-
-By default, the client sends traces via UDP to the agent at `localhost:6831`. Use `JAEGER_AGENT_HOST` and
-`JAEGER_AGENT_PORT` to send UDP traces to a different `host:port`. If `JAEGER_ENDPOINT` is set, the client sends traces
-to the endpoint via `HTTP`, making the `JAEGER_AGENT_HOST` and `JAEGER_AGENT_PORT` unused. If `JAEGER_ENDPOINT` is
-secured, HTTP basic authentication can be performed by setting the `JAEGER_USER` and `JAEGER_PASSWORD` environment
-variables.
-
-### Closing the tracer via `io.Closer`
-
-The constructor function for Jaeger Tracer returns the tracer itself and an `io.Closer` instance.
-It is recommended to structure your `main()` so that it calls the `Close()` function on the closer
-before exiting, e.g.
-
-```go
-tracer, closer, err := cfg.NewTracer(...)
-defer closer.Close()
-```
-
-This is especially useful for command-line tools that enable tracing, as well as
-for the long-running apps that support graceful shutdown. For example, if your deployment
-system sends SIGTERM instead of killing the process and you trap that signal to do a graceful
-exit, then having `defer closer.Close()` ensures that all buffered spans are flushed.
-
-### Metrics & Monitoring
-
-The tracer emits a number of different metrics, defined in
-[metrics.go](metrics.go). The monitoring backend is expected to support
-tag-based metric names, e.g. instead of `statsd`-style string names
-like `counters.my-service.jaeger.spans.started.sampled`, the metrics
-are defined by a short name and a collection of key/value tags, for
-example: `name:jaeger.traces, state:started, sampled:y`. See [metrics.go](./metrics.go)
-file for the full list and descriptions of emitted metrics.
-
-The monitoring backend is represented by the `metrics.Factory` interface from package
-[`"github.com/uber/jaeger-lib/metrics"`](https://github.com/jaegertracing/jaeger-lib/tree/master/metrics).  An implementation
-of that interface can be passed as an option to either the Configuration object or the Tracer
-constructor, for example:
-
-```go
-import (
-    "github.com/uber/jaeger-client-go/config"
-    "github.com/uber/jaeger-lib/metrics/prometheus"
-)
-
-    metricsFactory := prometheus.New()
-    tracer, closer, err := config.Configuration{
-        ServiceName: "your-service-name",
-    }.NewTracer(
-        config.Metrics(metricsFactory),
-    )
-```
-
-By default, a no-op `metrics.NullFactory` is used.
-
-### Logging
-
-The tracer can be configured with an optional logger, which will be
-used to log communication errors, or log spans if a logging reporter
-option is specified in the configuration. The logging API is abstracted
-by the [Logger](logger.go) interface. A logger instance implementing
-this interface can be set on the `Config` object before calling the
-`New` method.
-
-Besides the [zap](https://github.com/uber-go/zap) implementation
-bundled with this package there is also a [go-kit](https://github.com/go-kit/kit)
-one in the [jaeger-lib](https://github.com/jaegertracing/jaeger-lib) repository.
-
-## Instrumentation for Tracing
-
-Since this tracer is fully compliant with OpenTracing API 1.0,
-all code instrumentation should only use the API itself, as described
-in the [opentracing-go](https://github.com/opentracing/opentracing-go) documentation.
-
-## Features
-
-### Reporters
-
-A "reporter" is a component that receives the finished spans and reports
-them to somewhere. Under normal circumstances, the Tracer
-should use the default `RemoteReporter`, which sends the spans out of
-process via configurable "transport". For testing purposes, one can
-use an `InMemoryReporter` that accumulates spans in a buffer and
-allows to retrieve them for later verification. Also available are
-`NullReporter`, a no-op reporter that does nothing, a `LoggingReporter`
-which logs all finished spans using their `String()` method, and a
-`CompositeReporter` that can be used to combine more than one reporter
-into one, e.g. to attach a logging reporter to the main remote reporter.
-
-### Span Reporting Transports
-
-The remote reporter uses "transports" to actually send the spans out
-of process. Currently the supported transports include:
-  * [Jaeger Thrift](https://github.com/jaegertracing/jaeger-idl/blob/master/thrift/agent.thrift) over UDP or HTTP,
-  * [Zipkin Thrift](https://github.com/jaegertracing/jaeger-idl/blob/master/thrift/zipkincore.thrift) over HTTP.
-
-### Sampling
-
-The tracer does not record all spans, but only those that have the
-sampling bit set in the `flags`. When a new trace is started and a new
-unique ID is generated, a sampling decision is made whether this trace
-should be sampled. The sampling decision is propagated to all downstream
-calls via the `flags` field of the trace context. The following samplers
-are available:
-  1. `RemotelyControlledSampler` uses one of the other simpler samplers
-     and periodically updates it by polling an external server. This
-     allows dynamic control of the sampling strategies.
-  1. `ConstSampler` always makes the same sampling decision for all
-     trace IDs. it can be configured to either sample all traces, or
-     to sample none.
-  1. `ProbabilisticSampler` uses a fixed sampling rate as a probability
-     for a given trace to be sampled. The actual decision is made by
-     comparing the trace ID with a random number multiplied by the
-     sampling rate.
-  1. `RateLimitingSampler` can be used to allow only a certain fixed
-     number of traces to be sampled per second.
-
-#### Delayed sampling
-
-Version 2.20 introduced the ability to delay sampling decisions in the life cycle
-of the root span. It involves several features and architectural changes:
-  * **Shared sampling state**: the sampling state is shared across all local
-    (i.e. in-process) spans for a given trace.
-  * **New `SamplerV2` API** allows the sampler to be called at multiple points
-    in the life cycle of a span:
-    * on span creation
-    * on overwriting span operation name
-    * on setting span tags
-    * on finishing the span
-  * **Final/non-final sampling state**: the new `SamplerV2` API allows the sampler
-    to indicate if the negative sampling decision is final or not (positive sampling
-    decisions are always final). If the decision is not final, the sampler will be
-    called again on further span life cycle events, like setting tags.
-
-These new features are used in the experimental `x.TagMatchingSampler`, which
-can sample a trace based on a certain tag added to the root
-span or one of its local (in-process) children. The sampler can be used with
-another experimental `x.PrioritySampler` that allows multiple samplers to try
-to make a sampling decision, in a certain priority order.
-
-### Baggage Injection
-
-The OpenTracing spec allows for [baggage][baggage], which are key value pairs that are added
-to the span context and propagated throughout the trace. An external process can inject baggage
-by setting the special HTTP Header `jaeger-baggage` on a request:
-
-```sh
-curl -H "jaeger-baggage: key1=value1, key2=value2" http://myhost.com
-```
-
-Baggage can also be programatically set inside your service:
-
-```go
-if span := opentracing.SpanFromContext(ctx); span != nil {
-    span.SetBaggageItem("key", "value")
-}
-```
-
-Another service downstream of that can retrieve the baggage in a similar way:
-
-```go
-if span := opentracing.SpanFromContext(ctx); span != nil {
-    val := span.BaggageItem("key")
-    println(val)
-}
-```
-
-### Debug Traces (Forced Sampling)
-
-#### Programmatically
-
-The OpenTracing API defines a `sampling.priority` standard tag that
-can be used to affect the sampling of a span and its children:
-
-```go
-import (
-    "github.com/opentracing/opentracing-go"
-    "github.com/opentracing/opentracing-go/ext"
-)
-
-span := opentracing.SpanFromContext(ctx)
-ext.SamplingPriority.Set(span, 1)
-```
-
-#### Via HTTP Headers
-
-Jaeger Tracer also understands a special HTTP Header `jaeger-debug-id`,
-which can be set in the incoming request, e.g.
-
-```sh
-curl -H "jaeger-debug-id: some-correlation-id" http://myhost.com
-```
-
-When Jaeger sees this header in the request that otherwise has no
-tracing context, it ensures that the new trace started for this
-request will be sampled in the "debug" mode (meaning it should survive
-all downsampling that might happen in the collection pipeline), and the
-root span will have a tag as if this statement was executed:
-
-```go
-span.SetTag("jaeger-debug-id", "some-correlation-id")
-```
-
-This allows using Jaeger UI to find the trace by this tag.
-
-### Zipkin HTTP B3 compatible header propagation
-
-Jaeger Tracer supports Zipkin B3 Propagation HTTP headers, which are used
-by a lot of Zipkin tracers. This means that you can use Jaeger in conjunction with e.g. [these OpenZipkin tracers](https://github.com/openzipkin).
-
-However it is not the default propagation format, see [here](zipkin/README.md#NewZipkinB3HTTPHeaderPropagator) how to set it up.
-
-## SelfRef
-
-Jaeger Tracer supports an additional [span reference][] type call `Self`, which was proposed
-to the OpenTracing Specification (https://github.com/opentracing/specification/issues/81)
-but not yet accepted. This allows the caller to provide an already created `SpanContext`
-when starting a new span. The `Self` reference bypasses trace and span id generation,
-as well as sampling decisions (i.e. the sampling bit in the `SpanContext.flags` must be
-set appropriately by the caller).
-
-The `Self` reference supports the following use cases:
-  * the ability to provide externally generated trace and span IDs
-  * appending data to the same span from different processes, such as loading and continuing spans/traces from offline (ie log-based) storage
-
-Usage requires passing in a `SpanContext` and the `jaeger.Self` reference type:
-```
-span := tracer.StartSpan(
-    "continued_span",
-    jaeger.SelfRef(yourSpanContext),
-)
-...
-defer span.Finish()
-```
-
-## License
-
-[Apache 2.0 License](LICENSE).
-
-
-[doc-img]: https://pkg.go.dev/badge/github.com/uber/jaeger-client-go.svg
-[doc]: https://pkg.go.dev/github.com/uber/jaeger-client-go
-[ci-img]: https://travis-ci.org/jaegertracing/jaeger-client-go.svg?branch=master
-[ci]: https://travis-ci.org/jaegertracing/jaeger-client-go
-[cov-img]: https://codecov.io/gh/jaegertracing/jaeger-client-go/branch/master/graph/badge.svg
-[cov]: https://codecov.io/gh/jaegertracing/jaeger-client-go
-[ot-img]: https://img.shields.io/badge/OpenTracing--1.0-enabled-blue.svg
-[ot-url]: http://opentracing.io
-[baggage]: https://github.com/opentracing/specification/blob/master/specification.md#set-a-baggage-item
-[timeunits]: https://golang.org/pkg/time/#ParseDuration
-[span reference]: https://github.com/opentracing/specification/blob/1.1/specification.md#references-between-spans

vendor/github.com/uber/jaeger-client-go/RELEASE.md

@@ -1,12 +0,0 @@
-# Release Process
-
-1. Create a PR "Preparing for release X.Y.Z" against master branch
-    * Alter CHANGELOG.md from `<placeholder_version> (unreleased)` to `<X.Y.Z> (YYYY-MM-DD)`
-    * Use `git log --pretty=format:'- %s -- %an'` as the basis for for changelog entries
-    * Update `JaegerClientVersion` in constants.go to `Go-X.Y.Z`
-2. Create a release "Release X.Y.Z" on Github
-    * Create Tag `vX.Y.Z`
-    * Copy CHANGELOG.md into the release notes
-3. Create a PR "Back to development" against master branch
-    * Add `<next_version> (unreleased)` to CHANGELOG.md
-    * Update `JaegerClientVersion` in constants.go to `Go-<next_version>dev`

vendor/github.com/uber/jaeger-client-go/baggage_setter.go

@@ -1,77 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"github.com/opentracing/opentracing-go/log"
-
-	"github.com/uber/jaeger-client-go/internal/baggage"
-)
-
-// baggageSetter is an actor that can set a baggage value on a Span given certain
-// restrictions (eg. maxValueLength).
-type baggageSetter struct {
-	restrictionManager baggage.RestrictionManager
-	metrics            *Metrics
-}
-
-func newBaggageSetter(restrictionManager baggage.RestrictionManager, metrics *Metrics) *baggageSetter {
-	return &baggageSetter{
-		restrictionManager: restrictionManager,
-		metrics:            metrics,
-	}
-}
-
-// (NB) span should hold the lock before making this call
-func (s *baggageSetter) setBaggage(span *Span, key, value string) {
-	var truncated bool
-	var prevItem string
-	restriction := s.restrictionManager.GetRestriction(span.serviceName(), key)
-	if !restriction.KeyAllowed() {
-		s.logFields(span, key, value, prevItem, truncated, restriction.KeyAllowed())
-		s.metrics.BaggageUpdateFailure.Inc(1)
-		return
-	}
-	if len(value) > restriction.MaxValueLength() {
-		truncated = true
-		value = value[:restriction.MaxValueLength()]
-		s.metrics.BaggageTruncate.Inc(1)
-	}
-	prevItem = span.context.baggage[key]
-	s.logFields(span, key, value, prevItem, truncated, restriction.KeyAllowed())
-	span.context = span.context.WithBaggageItem(key, value)
-	s.metrics.BaggageUpdateSuccess.Inc(1)
-}
-
-func (s *baggageSetter) logFields(span *Span, key, value, prevItem string, truncated, valid bool) {
-	if !span.context.IsSampled() {
-		return
-	}
-	fields := []log.Field{
-		log.String("event", "baggage"),
-		log.String("key", key),
-		log.String("value", value),
-	}
-	if prevItem != "" {
-		fields = append(fields, log.String("override", "true"))
-	}
-	if truncated {
-		fields = append(fields, log.String("truncated", "true"))
-	}
-	if !valid {
-		fields = append(fields, log.String("invalid", "true"))
-	}
-	span.logFieldsNoLocking(fields...)
-}

vendor/github.com/uber/jaeger-client-go/config/config.go

@@ -1,447 +0,0 @@
-// Copyright (c) 2017-2018 Uber Technologies, Inc.
-//
-// 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 config
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-	"time"
-
-	"github.com/opentracing/opentracing-go"
-	"github.com/uber/jaeger-client-go/utils"
-
-	"github.com/uber/jaeger-client-go"
-	"github.com/uber/jaeger-client-go/internal/baggage/remote"
-	throttler "github.com/uber/jaeger-client-go/internal/throttler/remote"
-	"github.com/uber/jaeger-client-go/rpcmetrics"
-	"github.com/uber/jaeger-client-go/transport"
-	"github.com/uber/jaeger-lib/metrics"
-)
-
-const defaultSamplingProbability = 0.001
-
-// Configuration configures and creates Jaeger Tracer
-type Configuration struct {
-	// ServiceName specifies the service name to use on the tracer.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_SERVICE_NAME
-	ServiceName string `yaml:"serviceName"`
-
-	// Disabled makes the config return opentracing.NoopTracer.
-	// Value can be provided by FromEnv() via the environment variable named JAEGER_DISABLED.
-	Disabled bool `yaml:"disabled"`
-
-	// RPCMetrics enables generations of RPC metrics (requires metrics factory to be provided).
-	// Value can be provided by FromEnv() via the environment variable named JAEGER_RPC_METRICS
-	RPCMetrics bool `yaml:"rpc_metrics"`
-
-	// Gen128Bit instructs the tracer to generate 128-bit wide trace IDs, compatible with W3C Trace Context.
-	// Value can be provided by FromEnv() via the environment variable named JAEGER_TRACEID_128BIT.
-	Gen128Bit bool `yaml:"traceid_128bit"`
-
-	// Tags can be provided by FromEnv() via the environment variable named JAEGER_TAGS
-	Tags []opentracing.Tag `yaml:"tags"`
-
-	Sampler             *SamplerConfig             `yaml:"sampler"`
-	Reporter            *ReporterConfig            `yaml:"reporter"`
-	Headers             *jaeger.HeadersConfig      `yaml:"headers"`
-	BaggageRestrictions *BaggageRestrictionsConfig `yaml:"baggage_restrictions"`
-	Throttler           *ThrottlerConfig           `yaml:"throttler"`
-}
-
-// SamplerConfig allows initializing a non-default sampler.  All fields are optional.
-type SamplerConfig struct {
-	// Type specifies the type of the sampler: const, probabilistic, rateLimiting, or remote.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_SAMPLER_TYPE
-	Type string `yaml:"type"`
-
-	// Param is a value passed to the sampler.
-	// Valid values for Param field are:
-	// - for "const" sampler, 0 or 1 for always false/true respectively
-	// - for "probabilistic" sampler, a probability between 0 and 1
-	// - for "rateLimiting" sampler, the number of spans per second
-	// - for "remote" sampler, param is the same as for "probabilistic"
-	//   and indicates the initial sampling rate before the actual one
-	//   is received from the mothership.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_SAMPLER_PARAM
-	Param float64 `yaml:"param"`
-
-	// SamplingServerURL is the URL of sampling manager that can provide
-	// sampling strategy to this service.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_SAMPLING_ENDPOINT
-	SamplingServerURL string `yaml:"samplingServerURL"`
-
-	// SamplingRefreshInterval controls how often the remotely controlled sampler will poll
-	// sampling manager for the appropriate sampling strategy.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_SAMPLER_REFRESH_INTERVAL
-	SamplingRefreshInterval time.Duration `yaml:"samplingRefreshInterval"`
-
-	// MaxOperations is the maximum number of operations that the PerOperationSampler
-	// will keep track of. If an operation is not tracked, a default probabilistic
-	// sampler will be used rather than the per operation specific sampler.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_SAMPLER_MAX_OPERATIONS.
-	MaxOperations int `yaml:"maxOperations"`
-
-	// Opt-in feature for applications that require late binding of span name via explicit
-	// call to SetOperationName when using PerOperationSampler. When this feature is enabled,
-	// the sampler will return retryable=true from OnCreateSpan(), thus leaving the sampling
-	// decision as non-final (and the span as writeable). This may lead to degraded performance
-	// in applications that always provide the correct span name on trace creation.
-	//
-	// For backwards compatibility this option is off by default.
-	OperationNameLateBinding bool `yaml:"operationNameLateBinding"`
-
-	// Options can be used to programmatically pass additional options to the Remote sampler.
-	Options []jaeger.SamplerOption
-}
-
-// ReporterConfig configures the reporter. All fields are optional.
-type ReporterConfig struct {
-	// QueueSize controls how many spans the reporter can keep in memory before it starts dropping
-	// new spans. The queue is continuously drained by a background go-routine, as fast as spans
-	// can be sent out of process.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_REPORTER_MAX_QUEUE_SIZE
-	QueueSize int `yaml:"queueSize"`
-
-	// BufferFlushInterval controls how often the buffer is force-flushed, even if it's not full.
-	// It is generally not useful, as it only matters for very low traffic services.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_REPORTER_FLUSH_INTERVAL
-	BufferFlushInterval time.Duration
-
-	// LogSpans, when true, enables LoggingReporter that runs in parallel with the main reporter
-	// and logs all submitted spans. Main Configuration.Logger must be initialized in the code
-	// for this option to have any effect.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_REPORTER_LOG_SPANS
-	LogSpans bool `yaml:"logSpans"`
-
-	// LocalAgentHostPort instructs reporter to send spans to jaeger-agent at this address.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_AGENT_HOST / JAEGER_AGENT_PORT
-	LocalAgentHostPort string `yaml:"localAgentHostPort"`
-
-	// DisableAttemptReconnecting when true, disables udp connection helper that periodically re-resolves
-	// the agent's hostname and reconnects if there was a change. This option only
-	// applies if LocalAgentHostPort is specified.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_REPORTER_ATTEMPT_RECONNECTING_DISABLED
-	DisableAttemptReconnecting bool `yaml:"disableAttemptReconnecting"`
-
-	// AttemptReconnectInterval controls how often the agent client re-resolves the provided hostname
-	// in order to detect address changes. This option only applies if DisableAttemptReconnecting is false.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_REPORTER_ATTEMPT_RECONNECT_INTERVAL
-	AttemptReconnectInterval time.Duration
-
-	// CollectorEndpoint instructs reporter to send spans to jaeger-collector at this URL.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_ENDPOINT
-	CollectorEndpoint string `yaml:"collectorEndpoint"`
-
-	// User instructs reporter to include a user for basic http authentication when sending spans to jaeger-collector.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_USER
-	User string `yaml:"user"`
-
-	// Password instructs reporter to include a password for basic http authentication when sending spans to
-	// jaeger-collector.
-	// Can be provided by FromEnv() via the environment variable named JAEGER_PASSWORD
-	Password string `yaml:"password"`
-
-	// HTTPHeaders instructs the reporter to add these headers to the http request when reporting spans.
-	// This field takes effect only when using HTTPTransport by setting the CollectorEndpoint.
-	HTTPHeaders map[string]string `yaml:"http_headers"`
-}
-
-// BaggageRestrictionsConfig configures the baggage restrictions manager which can be used to whitelist
-// certain baggage keys. All fields are optional.
-type BaggageRestrictionsConfig struct {
-	// DenyBaggageOnInitializationFailure controls the startup failure mode of the baggage restriction
-	// manager. If true, the manager will not allow any baggage to be written until baggage restrictions have
-	// been retrieved from jaeger-agent. If false, the manager wil allow any baggage to be written until baggage
-	// restrictions have been retrieved from jaeger-agent.
-	DenyBaggageOnInitializationFailure bool `yaml:"denyBaggageOnInitializationFailure"`
-
-	// HostPort is the hostPort of jaeger-agent's baggage restrictions server
-	HostPort string `yaml:"hostPort"`
-
-	// RefreshInterval controls how often the baggage restriction manager will poll
-	// jaeger-agent for the most recent baggage restrictions.
-	RefreshInterval time.Duration `yaml:"refreshInterval"`
-}
-
-// ThrottlerConfig configures the throttler which can be used to throttle the
-// rate at which the client may send debug requests.
-type ThrottlerConfig struct {
-	// HostPort of jaeger-agent's credit server.
-	HostPort string `yaml:"hostPort"`
-
-	// RefreshInterval controls how often the throttler will poll jaeger-agent
-	// for more throttling credits.
-	RefreshInterval time.Duration `yaml:"refreshInterval"`
-
-	// SynchronousInitialization determines whether or not the throttler should
-	// synchronously fetch credits from the agent when an operation is seen for
-	// the first time. This should be set to true if the client will be used by
-	// a short lived service that needs to ensure that credits are fetched
-	// upfront such that sampling or throttling occurs.
-	SynchronousInitialization bool `yaml:"synchronousInitialization"`
-}
-
-type nullCloser struct{}
-
-func (*nullCloser) Close() error { return nil }
-
-// New creates a new Jaeger Tracer, and a closer func that can be used to flush buffers
-// before shutdown.
-//
-// Deprecated: use NewTracer() function
-func (c Configuration) New(
-	serviceName string,
-	options ...Option,
-) (opentracing.Tracer, io.Closer, error) {
-	if serviceName != "" {
-		c.ServiceName = serviceName
-	}
-
-	return c.NewTracer(options...)
-}
-
-// NewTracer returns a new tracer based on the current configuration, using the given options,
-// and a closer func that can be used to flush buffers before shutdown.
-func (c Configuration) NewTracer(options ...Option) (opentracing.Tracer, io.Closer, error) {
-	if c.Disabled {
-		return &opentracing.NoopTracer{}, &nullCloser{}, nil
-	}
-
-	if c.ServiceName == "" {
-		return nil, nil, errors.New("no service name provided")
-	}
-
-	opts := applyOptions(options...)
-	tracerMetrics := jaeger.NewMetrics(opts.metrics, nil)
-	if c.RPCMetrics {
-		Observer(
-			rpcmetrics.NewObserver(
-				opts.metrics.Namespace(metrics.NSOptions{Name: "jaeger-rpc", Tags: map[string]string{"component": "jaeger"}}),
-				rpcmetrics.DefaultNameNormalizer,
-			),
-		)(&opts) // adds to c.observers
-	}
-	if c.Sampler == nil {
-		c.Sampler = &SamplerConfig{
-			Type:  jaeger.SamplerTypeRemote,
-			Param: defaultSamplingProbability,
-		}
-	}
-	if c.Reporter == nil {
-		c.Reporter = &ReporterConfig{}
-	}
-
-	sampler := opts.sampler
-	if sampler == nil {
-		s, err := c.Sampler.NewSampler(c.ServiceName, tracerMetrics)
-		if err != nil {
-			return nil, nil, err
-		}
-		sampler = s
-	}
-
-	reporter := opts.reporter
-	if reporter == nil {
-		r, err := c.Reporter.NewReporter(c.ServiceName, tracerMetrics, opts.logger)
-		if err != nil {
-			return nil, nil, err
-		}
-		reporter = r
-	}
-
-	tracerOptions := []jaeger.TracerOption{
-		jaeger.TracerOptions.Metrics(tracerMetrics),
-		jaeger.TracerOptions.Logger(opts.logger),
-		jaeger.TracerOptions.CustomHeaderKeys(c.Headers),
-		jaeger.TracerOptions.PoolSpans(opts.poolSpans),
-		jaeger.TracerOptions.ZipkinSharedRPCSpan(opts.zipkinSharedRPCSpan),
-		jaeger.TracerOptions.MaxTagValueLength(opts.maxTagValueLength),
-		jaeger.TracerOptions.NoDebugFlagOnForcedSampling(opts.noDebugFlagOnForcedSampling),
-	}
-
-	if c.Gen128Bit || opts.gen128Bit {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.Gen128Bit(true))
-	}
-
-	if opts.randomNumber != nil {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.RandomNumber(opts.randomNumber))
-	}
-
-	for _, tag := range opts.tags {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.Tag(tag.Key, tag.Value))
-	}
-
-	for _, tag := range c.Tags {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.Tag(tag.Key, tag.Value))
-	}
-
-	for _, obs := range opts.observers {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.Observer(obs))
-	}
-
-	for _, cobs := range opts.contribObservers {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.ContribObserver(cobs))
-	}
-
-	for format, injector := range opts.injectors {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.Injector(format, injector))
-	}
-
-	for format, extractor := range opts.extractors {
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.Extractor(format, extractor))
-	}
-
-	if c.BaggageRestrictions != nil {
-		mgr := remote.NewRestrictionManager(
-			c.ServiceName,
-			remote.Options.Metrics(tracerMetrics),
-			remote.Options.Logger(opts.logger),
-			remote.Options.HostPort(c.BaggageRestrictions.HostPort),
-			remote.Options.RefreshInterval(c.BaggageRestrictions.RefreshInterval),
-			remote.Options.DenyBaggageOnInitializationFailure(
-				c.BaggageRestrictions.DenyBaggageOnInitializationFailure,
-			),
-		)
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.BaggageRestrictionManager(mgr))
-	}
-
-	if c.Throttler != nil {
-		debugThrottler := throttler.NewThrottler(
-			c.ServiceName,
-			throttler.Options.Metrics(tracerMetrics),
-			throttler.Options.Logger(opts.logger),
-			throttler.Options.HostPort(c.Throttler.HostPort),
-			throttler.Options.RefreshInterval(c.Throttler.RefreshInterval),
-			throttler.Options.SynchronousInitialization(
-				c.Throttler.SynchronousInitialization,
-			),
-		)
-
-		tracerOptions = append(tracerOptions, jaeger.TracerOptions.DebugThrottler(debugThrottler))
-	}
-
-	tracer, closer := jaeger.NewTracer(
-		c.ServiceName,
-		sampler,
-		reporter,
-		tracerOptions...,
-	)
-
-	return tracer, closer, nil
-}
-
-// InitGlobalTracer creates a new Jaeger Tracer, and sets it as global OpenTracing Tracer.
-// It returns a closer func that can be used to flush buffers before shutdown.
-func (c Configuration) InitGlobalTracer(
-	serviceName string,
-	options ...Option,
-) (io.Closer, error) {
-	if c.Disabled {
-		return &nullCloser{}, nil
-	}
-	tracer, closer, err := c.New(serviceName, options...)
-	if err != nil {
-		return nil, err
-	}
-	opentracing.SetGlobalTracer(tracer)
-	return closer, nil
-}
-
-// NewSampler creates a new sampler based on the configuration
-func (sc *SamplerConfig) NewSampler(
-	serviceName string,
-	metrics *jaeger.Metrics,
-) (jaeger.Sampler, error) {
-	samplerType := strings.ToLower(sc.Type)
-	if samplerType == jaeger.SamplerTypeConst {
-		return jaeger.NewConstSampler(sc.Param != 0), nil
-	}
-	if samplerType == jaeger.SamplerTypeProbabilistic {
-		if sc.Param >= 0 && sc.Param <= 1.0 {
-			return jaeger.NewProbabilisticSampler(sc.Param)
-		}
-		return nil, fmt.Errorf(
-			"invalid Param for probabilistic sampler; expecting value between 0 and 1, received %v",
-			sc.Param,
-		)
-	}
-	if samplerType == jaeger.SamplerTypeRateLimiting {
-		return jaeger.NewRateLimitingSampler(sc.Param), nil
-	}
-	if samplerType == jaeger.SamplerTypeRemote || sc.Type == "" {
-		sc2 := *sc
-		sc2.Type = jaeger.SamplerTypeProbabilistic
-		initSampler, err := sc2.NewSampler(serviceName, nil)
-		if err != nil {
-			return nil, err
-		}
-		options := []jaeger.SamplerOption{
-			jaeger.SamplerOptions.Metrics(metrics),
-			jaeger.SamplerOptions.InitialSampler(initSampler),
-			jaeger.SamplerOptions.SamplingServerURL(sc.SamplingServerURL),
-			jaeger.SamplerOptions.MaxOperations(sc.MaxOperations),
-			jaeger.SamplerOptions.OperationNameLateBinding(sc.OperationNameLateBinding),
-			jaeger.SamplerOptions.SamplingRefreshInterval(sc.SamplingRefreshInterval),
-		}
-		options = append(options, sc.Options...)
-		return jaeger.NewRemotelyControlledSampler(serviceName, options...), nil
-	}
-	return nil, fmt.Errorf("unknown sampler type (%s)", sc.Type)
-}
-
-// NewReporter instantiates a new reporter that submits spans to the collector
-func (rc *ReporterConfig) NewReporter(
-	serviceName string,
-	metrics *jaeger.Metrics,
-	logger jaeger.Logger,
-) (jaeger.Reporter, error) {
-	sender, err := rc.newTransport(logger)
-	if err != nil {
-		return nil, err
-	}
-	reporter := jaeger.NewRemoteReporter(
-		sender,
-		jaeger.ReporterOptions.QueueSize(rc.QueueSize),
-		jaeger.ReporterOptions.BufferFlushInterval(rc.BufferFlushInterval),
-		jaeger.ReporterOptions.Logger(logger),
-		jaeger.ReporterOptions.Metrics(metrics))
-	if rc.LogSpans && logger != nil {
-		logger.Infof("Initializing logging reporter")
-		reporter = jaeger.NewCompositeReporter(jaeger.NewLoggingReporter(logger), reporter)
-	}
-	return reporter, err
-}
-
-func (rc *ReporterConfig) newTransport(logger jaeger.Logger) (jaeger.Transport, error) {
-	switch {
-	case rc.CollectorEndpoint != "":
-		httpOptions := []transport.HTTPOption{transport.HTTPHeaders(rc.HTTPHeaders)}
-		if rc.User != "" && rc.Password != "" {
-			httpOptions = append(httpOptions, transport.HTTPBasicAuth(rc.User, rc.Password))
-		}
-		return transport.NewHTTPTransport(rc.CollectorEndpoint, httpOptions...), nil
-	default:
-		return jaeger.NewUDPTransportWithParams(jaeger.UDPTransportParams{
-			AgentClientUDPParams: utils.AgentClientUDPParams{
-				HostPort:                   rc.LocalAgentHostPort,
-				Logger:                     logger,
-				DisableAttemptReconnecting: rc.DisableAttemptReconnecting,
-				AttemptReconnectInterval:   rc.AttemptReconnectInterval,
-			},
-		})
-	}
-}

vendor/github.com/uber/jaeger-client-go/config/config_env.go

@@ -1,268 +0,0 @@
-// Copyright (c) 2018 The Jaeger 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 config
-
-import (
-	"fmt"
-	"net/url"
-	"os"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/opentracing/opentracing-go"
-	"github.com/pkg/errors"
-	"github.com/uber/jaeger-client-go"
-)
-
-const (
-	// environment variable names
-	envServiceName                         = "JAEGER_SERVICE_NAME"
-	envDisabled                            = "JAEGER_DISABLED"
-	envRPCMetrics                          = "JAEGER_RPC_METRICS"
-	envTags                                = "JAEGER_TAGS"
-	envSamplerType                         = "JAEGER_SAMPLER_TYPE"
-	envSamplerParam                        = "JAEGER_SAMPLER_PARAM"
-	envSamplerManagerHostPort              = "JAEGER_SAMPLER_MANAGER_HOST_PORT" // Deprecated by envSamplingEndpoint
-	envSamplingEndpoint                    = "JAEGER_SAMPLING_ENDPOINT"
-	envSamplerMaxOperations                = "JAEGER_SAMPLER_MAX_OPERATIONS"
-	envSamplerRefreshInterval              = "JAEGER_SAMPLER_REFRESH_INTERVAL"
-	envReporterMaxQueueSize                = "JAEGER_REPORTER_MAX_QUEUE_SIZE"
-	envReporterFlushInterval               = "JAEGER_REPORTER_FLUSH_INTERVAL"
-	envReporterLogSpans                    = "JAEGER_REPORTER_LOG_SPANS"
-	envReporterAttemptReconnectingDisabled = "JAEGER_REPORTER_ATTEMPT_RECONNECTING_DISABLED"
-	envReporterAttemptReconnectInterval    = "JAEGER_REPORTER_ATTEMPT_RECONNECT_INTERVAL"
-	envEndpoint                            = "JAEGER_ENDPOINT"
-	envUser                                = "JAEGER_USER"
-	envPassword                            = "JAEGER_PASSWORD"
-	envAgentHost                           = "JAEGER_AGENT_HOST"
-	envAgentPort                           = "JAEGER_AGENT_PORT"
-	env128bit                              = "JAEGER_TRACEID_128BIT"
-)
-
-// FromEnv uses environment variables to set the tracer's Configuration
-func FromEnv() (*Configuration, error) {
-	c := &Configuration{}
-	return c.FromEnv()
-}
-
-// FromEnv uses environment variables and overrides existing tracer's Configuration
-func (c *Configuration) FromEnv() (*Configuration, error) {
-	if e := os.Getenv(envServiceName); e != "" {
-		c.ServiceName = e
-	}
-
-	if e := os.Getenv(envRPCMetrics); e != "" {
-		if value, err := strconv.ParseBool(e); err == nil {
-			c.RPCMetrics = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envRPCMetrics, e)
-		}
-	}
-
-	if e := os.Getenv(envDisabled); e != "" {
-		if value, err := strconv.ParseBool(e); err == nil {
-			c.Disabled = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envDisabled, e)
-		}
-	}
-
-	if e := os.Getenv(envTags); e != "" {
-		c.Tags = parseTags(e)
-	}
-
-	if e := os.Getenv(env128bit); e != "" {
-		if value, err := strconv.ParseBool(e); err == nil {
-			c.Gen128Bit = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", env128bit, e)
-		}
-	}
-
-	if c.Sampler == nil {
-		c.Sampler = &SamplerConfig{}
-	}
-
-	if s, err := c.Sampler.samplerConfigFromEnv(); err == nil {
-		c.Sampler = s
-	} else {
-		return nil, errors.Wrap(err, "cannot obtain sampler config from env")
-	}
-
-	if c.Reporter == nil {
-		c.Reporter = &ReporterConfig{}
-	}
-
-	if r, err := c.Reporter.reporterConfigFromEnv(); err == nil {
-		c.Reporter = r
-	} else {
-		return nil, errors.Wrap(err, "cannot obtain reporter config from env")
-	}
-
-	return c, nil
-}
-
-// samplerConfigFromEnv creates a new SamplerConfig based on the environment variables
-func (sc *SamplerConfig) samplerConfigFromEnv() (*SamplerConfig, error) {
-	if e := os.Getenv(envSamplerType); e != "" {
-		sc.Type = e
-	}
-
-	if e := os.Getenv(envSamplerParam); e != "" {
-		if value, err := strconv.ParseFloat(e, 64); err == nil {
-			sc.Param = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerParam, e)
-		}
-	}
-
-	if e := os.Getenv(envSamplingEndpoint); e != "" {
-		sc.SamplingServerURL = e
-	} else if e := os.Getenv(envSamplerManagerHostPort); e != "" {
-		sc.SamplingServerURL = e
-	} else if e := os.Getenv(envAgentHost); e != "" {
-		// Fallback if we know the agent host - try the sampling endpoint there
-		sc.SamplingServerURL = fmt.Sprintf("http://%s:%d/sampling", e, jaeger.DefaultSamplingServerPort)
-	}
-
-	if e := os.Getenv(envSamplerMaxOperations); e != "" {
-		if value, err := strconv.ParseInt(e, 10, 0); err == nil {
-			sc.MaxOperations = int(value)
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerMaxOperations, e)
-		}
-	}
-
-	if e := os.Getenv(envSamplerRefreshInterval); e != "" {
-		if value, err := time.ParseDuration(e); err == nil {
-			sc.SamplingRefreshInterval = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envSamplerRefreshInterval, e)
-		}
-	}
-
-	return sc, nil
-}
-
-// reporterConfigFromEnv creates a new ReporterConfig based on the environment variables
-func (rc *ReporterConfig) reporterConfigFromEnv() (*ReporterConfig, error) {
-	if e := os.Getenv(envReporterMaxQueueSize); e != "" {
-		if value, err := strconv.ParseInt(e, 10, 0); err == nil {
-			rc.QueueSize = int(value)
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterMaxQueueSize, e)
-		}
-	}
-
-	if e := os.Getenv(envReporterFlushInterval); e != "" {
-		if value, err := time.ParseDuration(e); err == nil {
-			rc.BufferFlushInterval = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterFlushInterval, e)
-		}
-	}
-
-	if e := os.Getenv(envReporterLogSpans); e != "" {
-		if value, err := strconv.ParseBool(e); err == nil {
-			rc.LogSpans = value
-		} else {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterLogSpans, e)
-		}
-	}
-
-	if e := os.Getenv(envEndpoint); e != "" {
-		u, err := url.ParseRequestURI(e)
-		if err != nil {
-			return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envEndpoint, e)
-		}
-		rc.CollectorEndpoint = u.String()
-		user := os.Getenv(envUser)
-		pswd := os.Getenv(envPassword)
-		if user != "" && pswd == "" || user == "" && pswd != "" {
-			return nil, errors.Errorf("you must set %s and %s env vars together", envUser, envPassword)
-		}
-		rc.User = user
-		rc.Password = pswd
-	} else {
-		useEnv := false
-		host := jaeger.DefaultUDPSpanServerHost
-		if e := os.Getenv(envAgentHost); e != "" {
-			host = e
-			useEnv = true
-		}
-
-		port := jaeger.DefaultUDPSpanServerPort
-		if e := os.Getenv(envAgentPort); e != "" {
-			if value, err := strconv.ParseInt(e, 10, 0); err == nil {
-				port = int(value)
-				useEnv = true
-			} else {
-				return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envAgentPort, e)
-			}
-		}
-		if useEnv || rc.LocalAgentHostPort == "" {
-			rc.LocalAgentHostPort = fmt.Sprintf("%s:%d", host, port)
-		}
-
-		if e := os.Getenv(envReporterAttemptReconnectingDisabled); e != "" {
-			if value, err := strconv.ParseBool(e); err == nil {
-				rc.DisableAttemptReconnecting = value
-			} else {
-				return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterAttemptReconnectingDisabled, e)
-			}
-		}
-
-		if !rc.DisableAttemptReconnecting {
-			if e := os.Getenv(envReporterAttemptReconnectInterval); e != "" {
-				if value, err := time.ParseDuration(e); err == nil {
-					rc.AttemptReconnectInterval = value
-				} else {
-					return nil, errors.Wrapf(err, "cannot parse env var %s=%s", envReporterAttemptReconnectInterval, e)
-				}
-			}
-		}
-	}
-
-	return rc, nil
-}
-
-// parseTags parses the given string into a collection of Tags.
-// Spec for this value:
-// - comma separated list of key=value
-// - value can be specified using the notation ${envVar:defaultValue}, where `envVar`
-// is an environment variable and `defaultValue` is the value to use in case the env var is not set
-func parseTags(sTags string) []opentracing.Tag {
-	pairs := strings.Split(sTags, ",")
-	tags := make([]opentracing.Tag, 0)
-	for _, p := range pairs {
-		kv := strings.SplitN(p, "=", 2)
-		k, v := strings.TrimSpace(kv[0]), strings.TrimSpace(kv[1])
-
-		if strings.HasPrefix(v, "${") && strings.HasSuffix(v, "}") {
-			ed := strings.SplitN(v[2:len(v)-1], ":", 2)
-			e, d := ed[0], ed[1]
-			v = os.Getenv(e)
-			if v == "" && d != "" {
-				v = d
-			}
-		}
-
-		tag := opentracing.Tag{Key: k, Value: v}
-		tags = append(tags, tag)
-	}
-
-	return tags
-}

vendor/github.com/uber/jaeger-client-go/config/options.go

@@ -1,173 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 config
-
-import (
-	opentracing "github.com/opentracing/opentracing-go"
-	"github.com/uber/jaeger-lib/metrics"
-
-	"github.com/uber/jaeger-client-go"
-)
-
-// Option is a function that sets some option on the client.
-type Option func(c *Options)
-
-// Options control behavior of the client.
-type Options struct {
-	metrics                     metrics.Factory
-	logger                      jaeger.Logger
-	reporter                    jaeger.Reporter
-	sampler                     jaeger.Sampler
-	contribObservers            []jaeger.ContribObserver
-	observers                   []jaeger.Observer
-	gen128Bit                   bool
-	poolSpans                   bool
-	zipkinSharedRPCSpan         bool
-	maxTagValueLength           int
-	noDebugFlagOnForcedSampling bool
-	tags                        []opentracing.Tag
-	injectors                   map[interface{}]jaeger.Injector
-	extractors                  map[interface{}]jaeger.Extractor
-	randomNumber                func() uint64
-}
-
-// Metrics creates an Option that initializes Metrics in the tracer,
-// which is used to emit statistics about spans.
-func Metrics(factory metrics.Factory) Option {
-	return func(c *Options) {
-		c.metrics = factory
-	}
-}
-
-// Logger can be provided to log Reporter errors, as well as to log spans
-// if Reporter.LogSpans is set to true.
-func Logger(logger jaeger.Logger) Option {
-	return func(c *Options) {
-		c.logger = logger
-	}
-}
-
-// Reporter can be provided explicitly to override the configuration.
-// Useful for testing, e.g. by passing InMemoryReporter.
-func Reporter(reporter jaeger.Reporter) Option {
-	return func(c *Options) {
-		c.reporter = reporter
-	}
-}
-
-// Sampler can be provided explicitly to override the configuration.
-func Sampler(sampler jaeger.Sampler) Option {
-	return func(c *Options) {
-		c.sampler = sampler
-	}
-}
-
-// Observer can be registered with the Tracer to receive notifications about new Spans.
-func Observer(observer jaeger.Observer) Option {
-	return func(c *Options) {
-		c.observers = append(c.observers, observer)
-	}
-}
-
-// ContribObserver can be registered with the Tracer to receive notifications
-// about new spans.
-func ContribObserver(observer jaeger.ContribObserver) Option {
-	return func(c *Options) {
-		c.contribObservers = append(c.contribObservers, observer)
-	}
-}
-
-// Gen128Bit specifies whether to generate 128bit trace IDs.
-func Gen128Bit(gen128Bit bool) Option {
-	return func(c *Options) {
-		c.gen128Bit = gen128Bit
-	}
-}
-
-// PoolSpans specifies whether to pool spans
-func PoolSpans(poolSpans bool) Option {
-	return func(c *Options) {
-		c.poolSpans = poolSpans
-	}
-}
-
-// ZipkinSharedRPCSpan creates an option that enables sharing span ID between client
-// and server spans a la zipkin. If false, client and server spans will be assigned
-// different IDs.
-func ZipkinSharedRPCSpan(zipkinSharedRPCSpan bool) Option {
-	return func(c *Options) {
-		c.zipkinSharedRPCSpan = zipkinSharedRPCSpan
-	}
-}
-
-// MaxTagValueLength can be provided to override the default max tag value length.
-func MaxTagValueLength(maxTagValueLength int) Option {
-	return func(c *Options) {
-		c.maxTagValueLength = maxTagValueLength
-	}
-}
-
-// NoDebugFlagOnForcedSampling can be used to decide whether debug flag will be set or not
-// when calling span.setSamplingPriority to force sample a span.
-func NoDebugFlagOnForcedSampling(noDebugFlagOnForcedSampling bool) Option {
-	return func(c *Options) {
-		c.noDebugFlagOnForcedSampling = noDebugFlagOnForcedSampling
-	}
-}
-
-// Tag creates an option that adds a tracer-level tag.
-func Tag(key string, value interface{}) Option {
-	return func(c *Options) {
-		c.tags = append(c.tags, opentracing.Tag{Key: key, Value: value})
-	}
-}
-
-// Injector registers an Injector with the given format.
-func Injector(format interface{}, injector jaeger.Injector) Option {
-	return func(c *Options) {
-		c.injectors[format] = injector
-	}
-}
-
-// Extractor registers an Extractor with the given format.
-func Extractor(format interface{}, extractor jaeger.Extractor) Option {
-	return func(c *Options) {
-		c.extractors[format] = extractor
-	}
-}
-
-// WithRandomNumber supplies a random number generator function to the Tracer used to generate trace and span IDs.
-func WithRandomNumber(f func() uint64) Option {
-	return func(c *Options) {
-		c.randomNumber = f
-	}
-}
-
-func applyOptions(options ...Option) Options {
-	opts := Options{
-		injectors:  make(map[interface{}]jaeger.Injector),
-		extractors: make(map[interface{}]jaeger.Extractor),
-	}
-	for _, option := range options {
-		option(&opts)
-	}
-	if opts.metrics == nil {
-		opts.metrics = metrics.NullFactory
-	}
-	if opts.logger == nil {
-		opts.logger = jaeger.NullLogger
-	}
-	return opts
-}

vendor/github.com/uber/jaeger-client-go/constants.go

@@ -1,106 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"fmt"
-
-	"github.com/opentracing/opentracing-go"
-)
-
-const (
-	// JaegerClientVersion is the version of the client library reported as Span tag.
-	JaegerClientVersion = "Go-2.30.0"
-
-	// JaegerClientVersionTagKey is the name of the tag used to report client version.
-	JaegerClientVersionTagKey = "jaeger.version"
-
-	// JaegerDebugHeader is the name of HTTP header or a TextMap carrier key which,
-	// if found in the carrier, forces the trace to be sampled as "debug" trace.
-	// The value of the header is recorded as the tag on the root span, so that the
-	// trace can be found in the UI using this value as a correlation ID.
-	JaegerDebugHeader = "jaeger-debug-id"
-
-	// JaegerBaggageHeader is the name of the HTTP header that is used to submit baggage.
-	// It differs from TraceBaggageHeaderPrefix in that it can be used only in cases where
-	// a root span does not exist.
-	JaegerBaggageHeader = "jaeger-baggage"
-
-	// TracerHostnameTagKey used to report host name of the process.
-	TracerHostnameTagKey = "hostname"
-
-	// TracerIPTagKey used to report ip of the process.
-	TracerIPTagKey = "ip"
-
-	// TracerUUIDTagKey used to report UUID of the client process.
-	TracerUUIDTagKey = "client-uuid"
-
-	// SamplerTypeTagKey reports which sampler was used on the root span.
-	SamplerTypeTagKey = "sampler.type"
-
-	// SamplerParamTagKey reports the parameter of the sampler, like sampling probability.
-	SamplerParamTagKey = "sampler.param"
-
-	// TraceContextHeaderName is the http header name used to propagate tracing context.
-	// This must be in lower-case to avoid mismatches when decoding incoming headers.
-	TraceContextHeaderName = "uber-trace-id"
-
-	// TracerStateHeaderName is deprecated.
-	// Deprecated: use TraceContextHeaderName
-	TracerStateHeaderName = TraceContextHeaderName
-
-	// TraceBaggageHeaderPrefix is the prefix for http headers used to propagate baggage.
-	// This must be in lower-case to avoid mismatches when decoding incoming headers.
-	TraceBaggageHeaderPrefix = "uberctx-"
-
-	// SamplerTypeConst is the type of sampler that always makes the same decision.
-	SamplerTypeConst = "const"
-
-	// SamplerTypeRemote is the type of sampler that polls Jaeger agent for sampling strategy.
-	SamplerTypeRemote = "remote"
-
-	// SamplerTypeProbabilistic is the type of sampler that samples traces
-	// with a certain fixed probability.
-	SamplerTypeProbabilistic = "probabilistic"
-
-	// SamplerTypeRateLimiting is the type of sampler that samples
-	// only up to a fixed number of traces per second.
-	SamplerTypeRateLimiting = "ratelimiting"
-
-	// SamplerTypeLowerBound is the type of sampler that samples
-	// at least a fixed number of traces per second.
-	SamplerTypeLowerBound = "lowerbound"
-
-	// DefaultUDPSpanServerHost is the default host to send the spans to, via UDP
-	DefaultUDPSpanServerHost = "localhost"
-
-	// DefaultUDPSpanServerPort is the default port to send the spans to, via UDP
-	DefaultUDPSpanServerPort = 6831
-
-	// DefaultSamplingServerPort is the default port to fetch sampling config from, via http
-	DefaultSamplingServerPort = 5778
-
-	// DefaultMaxTagValueLength is the default max length of byte array or string allowed in the tag value.
-	DefaultMaxTagValueLength = 256
-
-	// SelfRefType is a jaeger specific reference type that supports creating a span
-	// with an already defined context.
-	selfRefType opentracing.SpanReferenceType = 99
-)
-
-var (
-	// DefaultSamplingServerURL is the default url to fetch sampling config from, via http
-	DefaultSamplingServerURL = fmt.Sprintf("http://127.0.0.1:%d/sampling", DefaultSamplingServerPort)
-)

vendor/github.com/uber/jaeger-client-go/contrib_observer.go

@@ -1,56 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	opentracing "github.com/opentracing/opentracing-go"
-)
-
-// ContribObserver can be registered with the Tracer to receive notifications
-// about new Spans. Modelled after github.com/opentracing-contrib/go-observer.
-type ContribObserver interface {
-	// Create and return a span observer. Called when a span starts.
-	// If the Observer is not interested in the given span, it must return (nil, false).
-	// E.g :
-	//     func StartSpan(opName string, opts ...opentracing.StartSpanOption) {
-	//         var sp opentracing.Span
-	//         sso := opentracing.StartSpanOptions{}
-	//         if spanObserver, ok := Observer.OnStartSpan(span, opName, sso); ok {
-	//             // we have a valid SpanObserver
-	//         }
-	//         ...
-	//     }
-	OnStartSpan(sp opentracing.Span, operationName string, options opentracing.StartSpanOptions) (ContribSpanObserver, bool)
-}
-
-// ContribSpanObserver is created by the Observer and receives notifications
-// about other Span events. This interface is meant to match
-// github.com/opentracing-contrib/go-observer, via duck typing, without
-// directly importing the go-observer package.
-type ContribSpanObserver interface {
-	OnSetOperationName(operationName string)
-	OnSetTag(key string, value interface{})
-	OnFinish(options opentracing.FinishOptions)
-}
-
-// wrapper observer for the old observers (see observer.go)
-type oldObserver struct {
-	obs Observer
-}
-
-func (o *oldObserver) OnStartSpan(sp opentracing.Span, operationName string, options opentracing.StartSpanOptions) (ContribSpanObserver, bool) {
-	spanObserver := o.obs.OnStartSpan(operationName, options)
-	return spanObserver, spanObserver != nil
-}

vendor/github.com/uber/jaeger-client-go/glide.lock

@@ -1,105 +0,0 @@
-hash: 63bec420a22b7e5abac8c602c5cc9b66a33d6a1bfec8918eecc77fd344b759ed
-updated: 2020-07-31T13:30:37.242608-04:00
-imports:
-- name: github.com/beorn7/perks
-  version: 3a771d992973f24aa725d07868b467d1ddfceafb
-  subpackages:
-  - quantile
-- name: github.com/HdrHistogram/hdrhistogram-go
-  version: 3a0bb77429bd3a61596f5e8a3172445844342120
-- name: github.com/crossdock/crossdock-go
-  version: 049aabb0122b03bc9bd30cab8f3f91fb60166361
-  subpackages:
-  - assert
-  - require
-- name: github.com/davecgh/go-spew
-  version: 8991bc29aa16c548c550c7ff78260e27b9ab7c73
-  subpackages:
-  - spew
-- name: github.com/golang/mock
-  version: 51421b967af1f557f93a59e0057aaf15ca02e29c
-  subpackages:
-  - gomock
-- name: github.com/golang/protobuf
-  version: b5d812f8a3706043e23a9cd5babf2e5423744d30
-  subpackages:
-  - proto
-- name: github.com/matttproud/golang_protobuf_extensions
-  version: c182affec369e30f25d3eb8cd8a478dee585ae7d
-  subpackages:
-  - pbutil
-- name: github.com/opentracing/opentracing-go
-  version: d34af3eaa63c4d08ab54863a4bdd0daa45212e12
-  subpackages:
-  - ext
-  - harness
-  - log
-- name: github.com/pkg/errors
-  version: ba968bfe8b2f7e042a574c888954fccecfa385b4
-- name: github.com/pmezard/go-difflib
-  version: 5d4384ee4fb2527b0a1256a821ebfc92f91efefc
-  subpackages:
-  - difflib
-- name: github.com/prometheus/client_golang
-  version: 170205fb58decfd011f1550d4cfb737230d7ae4f
-  subpackages:
-  - prometheus
-  - prometheus/internal
-- name: github.com/prometheus/client_model
-  version: fd36f4220a901265f90734c3183c5f0c91daa0b8
-  subpackages:
-  - go
-- name: github.com/prometheus/common
-  version: 1ab4d74fc89940cfbc3c2b3a89821336cdefa119
-  subpackages:
-  - expfmt
-  - internal/bitbucket.org/ww/goautoneg
-  - model
-- name: github.com/prometheus/procfs
-  version: 8a055596020d692cf491851e47ba3e302d9f90ce
-  subpackages:
-  - internal/fs
-  - internal/util
-- name: github.com/stretchr/testify
-  version: f654a9112bbeac49ca2cd45bfbe11533c4666cf8
-  subpackages:
-  - assert
-  - mock
-  - require
-  - suite
-- name: github.com/uber-go/atomic
-  version: 845920076a298bdb984fb0f1b86052e4ca0a281c
-- name: github.com/uber/jaeger-lib
-  version: 48cc1df63e6be0d63b95677f0d22beb880bce1e4
-  subpackages:
-  - metrics
-  - metrics/metricstest
-  - metrics/prometheus
-- name: go.uber.org/atomic
-  version: 845920076a298bdb984fb0f1b86052e4ca0a281c
-- name: go.uber.org/multierr
-  version: b587143a48b62b01d337824eab43700af6ffe222
-- name: go.uber.org/zap
-  version: feeb9a050b31b40eec6f2470e7599eeeadfe5bdd
-  subpackages:
-  - buffer
-  - internal/bufferpool
-  - internal/color
-  - internal/exit
-  - zapcore
-  - zaptest/observer
-- name: golang.org/x/net
-  version: addf6b3196f61cd44ce5a76657913698c73479d0
-  subpackages:
-  - context
-  - context/ctxhttp
-- name: golang.org/x/sys
-  version: 3e129f6d46b10b0e1da36b3deffcb55e09631b64
-  subpackages:
-  - internal/unsafeheader
-  - windows
-- name: gopkg.in/yaml.v3
-  version: eeeca48fe7764f320e4870d231902bf9c1be2c08
-testImports:
-- name: github.com/stretchr/objx
-  version: 35313a95ee26395aa17d366c71a2ccf788fa69b6

vendor/github.com/uber/jaeger-client-go/glide.yaml

@@ -1,30 +0,0 @@
-package: github.com/uber/jaeger-client-go
-import:
-- package: github.com/opentracing/opentracing-go
-  version: ^1.2
-  subpackages:
-  - ext
-  - log
-- package: github.com/crossdock/crossdock-go
-- package: github.com/uber/jaeger-lib
-  version: ^2.3.0
-  subpackages:
-  - metrics
-- package: github.com/pkg/errors
-  version: ~0.8.0
-- package: go.uber.org/zap
-  source: https://github.com/uber-go/zap.git
-  version: ^1
-- package: github.com/uber-go/atomic
-  version: ^1
-- package: github.com/prometheus/client_golang
-  version: 1.1
-- package: github.com/prometheus/procfs
-  version: 0.0.6
-testImport:
-- package: github.com/stretchr/testify
-  subpackages:
-  - assert
-  - require
-  - suite
-- package: github.com/golang/mock

vendor/github.com/uber/jaeger-client-go/header.go

@@ -1,65 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-// HeadersConfig contains the values for the header keys that Jaeger will use.
-// These values may be either custom or default depending on whether custom
-// values were provided via a configuration.
-type HeadersConfig struct {
-	// JaegerDebugHeader is the name of HTTP header or a TextMap carrier key which,
-	// if found in the carrier, forces the trace to be sampled as "debug" trace.
-	// The value of the header is recorded as the tag on the root span, so that the
-	// trace can be found in the UI using this value as a correlation ID.
-	JaegerDebugHeader string `yaml:"jaegerDebugHeader"`
-
-	// JaegerBaggageHeader is the name of the HTTP header that is used to submit baggage.
-	// It differs from TraceBaggageHeaderPrefix in that it can be used only in cases where
-	// a root span does not exist.
-	JaegerBaggageHeader string `yaml:"jaegerBaggageHeader"`
-
-	// TraceContextHeaderName is the http header name used to propagate tracing context.
-	// This must be in lower-case to avoid mismatches when decoding incoming headers.
-	TraceContextHeaderName string `yaml:"TraceContextHeaderName"`
-
-	// TraceBaggageHeaderPrefix is the prefix for http headers used to propagate baggage.
-	// This must be in lower-case to avoid mismatches when decoding incoming headers.
-	TraceBaggageHeaderPrefix string `yaml:"traceBaggageHeaderPrefix"`
-}
-
-// ApplyDefaults sets missing configuration keys to default values
-func (c *HeadersConfig) ApplyDefaults() *HeadersConfig {
-	if c.JaegerBaggageHeader == "" {
-		c.JaegerBaggageHeader = JaegerBaggageHeader
-	}
-	if c.JaegerDebugHeader == "" {
-		c.JaegerDebugHeader = JaegerDebugHeader
-	}
-	if c.TraceBaggageHeaderPrefix == "" {
-		c.TraceBaggageHeaderPrefix = TraceBaggageHeaderPrefix
-	}
-	if c.TraceContextHeaderName == "" {
-		c.TraceContextHeaderName = TraceContextHeaderName
-	}
-	return c
-}
-
-func getDefaultHeadersConfig() *HeadersConfig {
-	return &HeadersConfig{
-		JaegerDebugHeader:        JaegerDebugHeader,
-		JaegerBaggageHeader:      JaegerBaggageHeader,
-		TraceContextHeaderName:   TraceContextHeaderName,
-		TraceBaggageHeaderPrefix: TraceBaggageHeaderPrefix,
-	}
-}

vendor/github.com/uber/jaeger-client-go/internal/baggage/remote/options.go

@@ -1,101 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 remote
-
-import (
-	"time"
-
-	"github.com/uber/jaeger-client-go"
-)
-
-const (
-	defaultMaxValueLength  = 2048
-	defaultRefreshInterval = time.Minute
-	defaultHostPort        = "localhost:5778"
-)
-
-// Option is a function that sets some option on the RestrictionManager
-type Option func(options *options)
-
-// Options is a factory for all available options
-var Options options
-
-type options struct {
-	denyBaggageOnInitializationFailure bool
-	metrics                            *jaeger.Metrics
-	logger                             jaeger.Logger
-	hostPort                           string
-	refreshInterval                    time.Duration
-}
-
-// DenyBaggageOnInitializationFailure creates an Option that determines the startup failure mode of RestrictionManager.
-// If DenyBaggageOnInitializationFailure is true, RestrictionManager will not allow any baggage to be written until baggage
-// restrictions have been retrieved from agent.
-// If DenyBaggageOnInitializationFailure is false, RestrictionManager will allow any baggage to be written until baggage
-// restrictions have been retrieved from agent.
-func (options) DenyBaggageOnInitializationFailure(b bool) Option {
-	return func(o *options) {
-		o.denyBaggageOnInitializationFailure = b
-	}
-}
-
-// Metrics creates an Option that initializes Metrics on the RestrictionManager, which is used to emit statistics.
-func (options) Metrics(m *jaeger.Metrics) Option {
-	return func(o *options) {
-		o.metrics = m
-	}
-}
-
-// Logger creates an Option that sets the logger used by the RestrictionManager.
-func (options) Logger(logger jaeger.Logger) Option {
-	return func(o *options) {
-		o.logger = logger
-	}
-}
-
-// HostPort creates an Option that sets the hostPort of the local agent that contains the baggage restrictions.
-func (options) HostPort(hostPort string) Option {
-	return func(o *options) {
-		o.hostPort = hostPort
-	}
-}
-
-// RefreshInterval creates an Option that sets how often the RestrictionManager will poll local agent for
-// the baggage restrictions.
-func (options) RefreshInterval(refreshInterval time.Duration) Option {
-	return func(o *options) {
-		o.refreshInterval = refreshInterval
-	}
-}
-
-func applyOptions(o ...Option) options {
-	opts := options{}
-	for _, option := range o {
-		option(&opts)
-	}
-	if opts.metrics == nil {
-		opts.metrics = jaeger.NewNullMetrics()
-	}
-	if opts.logger == nil {
-		opts.logger = jaeger.NullLogger
-	}
-	if opts.hostPort == "" {
-		opts.hostPort = defaultHostPort
-	}
-	if opts.refreshInterval == 0 {
-		opts.refreshInterval = defaultRefreshInterval
-	}
-	return opts
-}

vendor/github.com/uber/jaeger-client-go/internal/baggage/remote/restriction_manager.go

@@ -1,158 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 remote
-
-import (
-	"context"
-	"fmt"
-	"net/url"
-	"sync"
-	"time"
-
-	"github.com/uber/jaeger-client-go/internal/baggage"
-	thrift "github.com/uber/jaeger-client-go/thrift-gen/baggage"
-	"github.com/uber/jaeger-client-go/utils"
-)
-
-type httpBaggageRestrictionManagerProxy struct {
-	url string
-}
-
-func newHTTPBaggageRestrictionManagerProxy(hostPort, serviceName string) *httpBaggageRestrictionManagerProxy {
-	v := url.Values{}
-	v.Set("service", serviceName)
-	return &httpBaggageRestrictionManagerProxy{
-		url: fmt.Sprintf("http://%s/baggageRestrictions?%s", hostPort, v.Encode()),
-	}
-}
-
-func (s *httpBaggageRestrictionManagerProxy) GetBaggageRestrictions(context.Context, string) ([]*thrift.BaggageRestriction, error) {
-	var out []*thrift.BaggageRestriction
-	if err := utils.GetJSON(s.url, &out); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// RestrictionManager manages baggage restrictions by retrieving baggage restrictions from agent
-type RestrictionManager struct {
-	options
-
-	mux                sync.RWMutex
-	serviceName        string
-	restrictions       map[string]*baggage.Restriction
-	thriftProxy        thrift.BaggageRestrictionManager
-	pollStopped        sync.WaitGroup
-	stopPoll           chan struct{}
-	invalidRestriction *baggage.Restriction
-	validRestriction   *baggage.Restriction
-
-	// Determines if the manager has successfully retrieved baggage restrictions from agent
-	initialized bool
-}
-
-// NewRestrictionManager returns a BaggageRestrictionManager that polls the agent for the latest
-// baggage restrictions.
-func NewRestrictionManager(serviceName string, options ...Option) *RestrictionManager {
-	// TODO there is a developing use case where a single tracer can generate traces on behalf of many services.
-	// restrictionsMap will need to exist per service
-	opts := applyOptions(options...)
-	m := &RestrictionManager{
-		serviceName:        serviceName,
-		options:            opts,
-		restrictions:       make(map[string]*baggage.Restriction),
-		thriftProxy:        newHTTPBaggageRestrictionManagerProxy(opts.hostPort, serviceName),
-		stopPoll:           make(chan struct{}),
-		invalidRestriction: baggage.NewRestriction(false, 0),
-		validRestriction:   baggage.NewRestriction(true, defaultMaxValueLength),
-	}
-	m.pollStopped.Add(1)
-	go m.pollManager()
-	return m
-}
-
-// isReady returns true if the manager has retrieved baggage restrictions from the remote source.
-func (m *RestrictionManager) isReady() bool {
-	m.mux.RLock()
-	defer m.mux.RUnlock()
-	return m.initialized
-}
-
-// GetRestriction implements RestrictionManager#GetRestriction.
-func (m *RestrictionManager) GetRestriction(service, key string) *baggage.Restriction {
-	m.mux.RLock()
-	defer m.mux.RUnlock()
-	if !m.initialized {
-		if m.denyBaggageOnInitializationFailure {
-			return m.invalidRestriction
-		}
-		return m.validRestriction
-	}
-	if restriction, ok := m.restrictions[key]; ok {
-		return restriction
-	}
-	return m.invalidRestriction
-}
-
-// Close stops remote polling and closes the RemoteRestrictionManager.
-func (m *RestrictionManager) Close() error {
-	close(m.stopPoll)
-	m.pollStopped.Wait()
-	return nil
-}
-
-func (m *RestrictionManager) pollManager() {
-	defer m.pollStopped.Done()
-	// attempt to initialize baggage restrictions
-	if err := m.updateRestrictions(); err != nil {
-		m.logger.Error(fmt.Sprintf("Failed to initialize baggage restrictions: %s", err.Error()))
-	}
-	ticker := time.NewTicker(m.refreshInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-ticker.C:
-			if err := m.updateRestrictions(); err != nil {
-				m.logger.Error(fmt.Sprintf("Failed to update baggage restrictions: %s", err.Error()))
-			}
-		case <-m.stopPoll:
-			return
-		}
-	}
-}
-
-func (m *RestrictionManager) updateRestrictions() error {
-	restrictions, err := m.thriftProxy.GetBaggageRestrictions(context.Background(), m.serviceName)
-	if err != nil {
-		m.metrics.BaggageRestrictionsUpdateFailure.Inc(1)
-		return err
-	}
-	newRestrictions := m.parseRestrictions(restrictions)
-	m.metrics.BaggageRestrictionsUpdateSuccess.Inc(1)
-	m.mux.Lock()
-	defer m.mux.Unlock()
-	m.initialized = true
-	m.restrictions = newRestrictions
-	return nil
-}
-
-func (m *RestrictionManager) parseRestrictions(restrictions []*thrift.BaggageRestriction) map[string]*baggage.Restriction {
-	setters := make(map[string]*baggage.Restriction, len(restrictions))
-	for _, restriction := range restrictions {
-		setters[restriction.BaggageKey] = baggage.NewRestriction(true, int(restriction.MaxValueLength))
-	}
-	return setters
-}

vendor/github.com/uber/jaeger-client-go/internal/baggage/restriction_manager.go

@@ -1,71 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 baggage
-
-const (
-	defaultMaxValueLength = 2048
-)
-
-// Restriction determines whether a baggage key is allowed and contains any restrictions on the baggage value.
-type Restriction struct {
-	keyAllowed     bool
-	maxValueLength int
-}
-
-// NewRestriction returns a new Restriction.
-func NewRestriction(keyAllowed bool, maxValueLength int) *Restriction {
-	return &Restriction{
-		keyAllowed:     keyAllowed,
-		maxValueLength: maxValueLength,
-	}
-}
-
-// KeyAllowed returns whether the baggage key for this restriction is allowed.
-func (r *Restriction) KeyAllowed() bool {
-	return r.keyAllowed
-}
-
-// MaxValueLength returns the max length for the baggage value.
-func (r *Restriction) MaxValueLength() int {
-	return r.maxValueLength
-}
-
-// RestrictionManager keeps track of valid baggage keys and their restrictions. The manager
-// will return a Restriction for a specific baggage key which will determine whether the baggage
-// key is allowed for the current service and any other applicable restrictions on the baggage
-// value.
-type RestrictionManager interface {
-	GetRestriction(service, key string) *Restriction
-}
-
-// DefaultRestrictionManager allows any baggage key.
-type DefaultRestrictionManager struct {
-	defaultRestriction *Restriction
-}
-
-// NewDefaultRestrictionManager returns a DefaultRestrictionManager.
-func NewDefaultRestrictionManager(maxValueLength int) *DefaultRestrictionManager {
-	if maxValueLength == 0 {
-		maxValueLength = defaultMaxValueLength
-	}
-	return &DefaultRestrictionManager{
-		defaultRestriction: &Restriction{keyAllowed: true, maxValueLength: maxValueLength},
-	}
-}
-
-// GetRestriction implements RestrictionManager#GetRestriction.
-func (m *DefaultRestrictionManager) GetRestriction(service, key string) *Restriction {
-	return m.defaultRestriction
-}

vendor/github.com/uber/jaeger-client-go/internal/spanlog/json.go

@@ -1,81 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 spanlog
-
-import (
-	"encoding/json"
-	"fmt"
-
-	"github.com/opentracing/opentracing-go/log"
-)
-
-type fieldsAsMap map[string]string
-
-// MaterializeWithJSON converts log Fields into JSON string
-// TODO refactor into pluggable materializer
-func MaterializeWithJSON(logFields []log.Field) ([]byte, error) {
-	fields := fieldsAsMap(make(map[string]string, len(logFields)))
-	for _, field := range logFields {
-		field.Marshal(fields)
-	}
-	if event, ok := fields["event"]; ok && len(fields) == 1 {
-		return []byte(event), nil
-	}
-	return json.Marshal(fields)
-}
-
-func (ml fieldsAsMap) EmitString(key, value string) {
-	ml[key] = value
-}
-
-func (ml fieldsAsMap) EmitBool(key string, value bool) {
-	ml[key] = fmt.Sprintf("%t", value)
-}
-
-func (ml fieldsAsMap) EmitInt(key string, value int) {
-	ml[key] = fmt.Sprintf("%d", value)
-}
-
-func (ml fieldsAsMap) EmitInt32(key string, value int32) {
-	ml[key] = fmt.Sprintf("%d", value)
-}
-
-func (ml fieldsAsMap) EmitInt64(key string, value int64) {
-	ml[key] = fmt.Sprintf("%d", value)
-}
-
-func (ml fieldsAsMap) EmitUint32(key string, value uint32) {
-	ml[key] = fmt.Sprintf("%d", value)
-}
-
-func (ml fieldsAsMap) EmitUint64(key string, value uint64) {
-	ml[key] = fmt.Sprintf("%d", value)
-}
-
-func (ml fieldsAsMap) EmitFloat32(key string, value float32) {
-	ml[key] = fmt.Sprintf("%f", value)
-}
-
-func (ml fieldsAsMap) EmitFloat64(key string, value float64) {
-	ml[key] = fmt.Sprintf("%f", value)
-}
-
-func (ml fieldsAsMap) EmitObject(key string, value interface{}) {
-	ml[key] = fmt.Sprintf("%+v", value)
-}
-
-func (ml fieldsAsMap) EmitLazyLogger(value log.LazyLogger) {
-	value(ml)
-}

vendor/github.com/uber/jaeger-client-go/internal/throttler/remote/options.go

@@ -1,99 +0,0 @@
-// Copyright (c) 2018 The Jaeger 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 remote
-
-import (
-	"time"
-
-	"github.com/uber/jaeger-client-go"
-)
-
-const (
-	defaultHostPort        = "localhost:5778"
-	defaultRefreshInterval = time.Second * 5
-)
-
-// Option is a function that sets some option on the Throttler
-type Option func(options *options)
-
-// Options is a factory for all available options
-var Options options
-
-type options struct {
-	metrics                   *jaeger.Metrics
-	logger                    jaeger.Logger
-	hostPort                  string
-	refreshInterval           time.Duration
-	synchronousInitialization bool
-}
-
-// Metrics creates an Option that initializes Metrics on the Throttler, which is used to emit statistics.
-func (options) Metrics(m *jaeger.Metrics) Option {
-	return func(o *options) {
-		o.metrics = m
-	}
-}
-
-// Logger creates an Option that sets the logger used by the Throttler.
-func (options) Logger(logger jaeger.Logger) Option {
-	return func(o *options) {
-		o.logger = logger
-	}
-}
-
-// HostPort creates an Option that sets the hostPort of the local agent that keeps track of credits.
-func (options) HostPort(hostPort string) Option {
-	return func(o *options) {
-		o.hostPort = hostPort
-	}
-}
-
-// RefreshInterval creates an Option that sets how often the Throttler will poll local agent for
-// credits.
-func (options) RefreshInterval(refreshInterval time.Duration) Option {
-	return func(o *options) {
-		o.refreshInterval = refreshInterval
-	}
-}
-
-// SynchronousInitialization creates an Option that determines whether the throttler should synchronously
-// fetch credits from the agent when an operation is seen for the first time. This should be set to true
-// if the client will be used by a short lived service that needs to ensure that credits are fetched upfront
-// such that sampling or throttling occurs.
-func (options) SynchronousInitialization(b bool) Option {
-	return func(o *options) {
-		o.synchronousInitialization = b
-	}
-}
-
-func applyOptions(o ...Option) options {
-	opts := options{}
-	for _, option := range o {
-		option(&opts)
-	}
-	if opts.metrics == nil {
-		opts.metrics = jaeger.NewNullMetrics()
-	}
-	if opts.logger == nil {
-		opts.logger = jaeger.NullLogger
-	}
-	if opts.hostPort == "" {
-		opts.hostPort = defaultHostPort
-	}
-	if opts.refreshInterval == 0 {
-		opts.refreshInterval = defaultRefreshInterval
-	}
-	return opts
-}

vendor/github.com/uber/jaeger-client-go/internal/throttler/remote/throttler.go

@@ -1,216 +0,0 @@
-// Copyright (c) 2018 The Jaeger 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 remote
-
-import (
-	"fmt"
-	"net/url"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/pkg/errors"
-
-	"github.com/uber/jaeger-client-go"
-	"github.com/uber/jaeger-client-go/utils"
-)
-
-const (
-	// minimumCredits is the minimum amount of credits necessary to not be throttled.
-	// i.e. if currentCredits > minimumCredits, then the operation will not be throttled.
-	minimumCredits = 1.0
-)
-
-var (
-	errorUUIDNotSet = errors.New("Throttler UUID must be set")
-)
-
-type operationBalance struct {
-	Operation string  `json:"operation"`
-	Balance   float64 `json:"balance"`
-}
-
-type creditResponse struct {
-	Balances []operationBalance `json:"balances"`
-}
-
-type httpCreditManagerProxy struct {
-	hostPort string
-}
-
-func newHTTPCreditManagerProxy(hostPort string) *httpCreditManagerProxy {
-	return &httpCreditManagerProxy{
-		hostPort: hostPort,
-	}
-}
-
-// N.B. Operations list must not be empty.
-func (m *httpCreditManagerProxy) FetchCredits(uuid, serviceName string, operations []string) (*creditResponse, error) {
-	params := url.Values{}
-	params.Set("service", serviceName)
-	params.Set("uuid", uuid)
-	for _, op := range operations {
-		params.Add("operations", op)
-	}
-	var resp creditResponse
-	if err := utils.GetJSON(fmt.Sprintf("http://%s/credits?%s", m.hostPort, params.Encode()), &resp); err != nil {
-		return nil, errors.Wrap(err, "Failed to receive credits from agent")
-	}
-	return &resp, nil
-}
-
-// Throttler retrieves credits from agent and uses it to throttle operations.
-type Throttler struct {
-	options
-
-	mux           sync.RWMutex
-	service       string
-	uuid          atomic.Value
-	creditManager *httpCreditManagerProxy
-	credits       map[string]float64 // map of operation->credits
-	close         chan struct{}
-	stopped       sync.WaitGroup
-}
-
-// NewThrottler returns a Throttler that polls agent for credits and uses them to throttle
-// the service.
-func NewThrottler(service string, options ...Option) *Throttler {
-	opts := applyOptions(options...)
-	creditManager := newHTTPCreditManagerProxy(opts.hostPort)
-	t := &Throttler{
-		options:       opts,
-		creditManager: creditManager,
-		service:       service,
-		credits:       make(map[string]float64),
-		close:         make(chan struct{}),
-	}
-	t.stopped.Add(1)
-	go t.pollManager()
-	return t
-}
-
-// IsAllowed implements Throttler#IsAllowed.
-func (t *Throttler) IsAllowed(operation string) bool {
-	t.mux.Lock()
-	defer t.mux.Unlock()
-	value, ok := t.credits[operation]
-	if !ok || value == 0 {
-		if !ok {
-			// NOTE: This appears to be a no-op at first glance, but it stores
-			// the operation key in the map. Necessary for functionality of
-			// Throttler#operations method.
-			t.credits[operation] = 0
-		}
-		if !t.synchronousInitialization {
-			t.metrics.ThrottledDebugSpans.Inc(1)
-			return false
-		}
-		// If it is the first time this operation is being checked, synchronously fetch
-		// the credits.
-		credits, err := t.fetchCredits([]string{operation})
-		if err != nil {
-			// Failed to receive credits from agent, try again next time
-			t.logger.Error("Failed to fetch credits: " + err.Error())
-			return false
-		}
-		if len(credits.Balances) == 0 {
-			// This shouldn't happen but just in case
-			return false
-		}
-		for _, opBalance := range credits.Balances {
-			t.credits[opBalance.Operation] += opBalance.Balance
-		}
-	}
-	return t.isAllowed(operation)
-}
-
-// Close stops the throttler from fetching credits from remote.
-func (t *Throttler) Close() error {
-	close(t.close)
-	t.stopped.Wait()
-	return nil
-}
-
-// SetProcess implements ProcessSetter#SetProcess. It's imperative that the UUID is set before any remote
-// requests are made.
-func (t *Throttler) SetProcess(process jaeger.Process) {
-	if process.UUID != "" {
-		t.uuid.Store(process.UUID)
-	}
-}
-
-// N.B. This function must be called with the Write Lock
-func (t *Throttler) isAllowed(operation string) bool {
-	credits := t.credits[operation]
-	if credits < minimumCredits {
-		t.metrics.ThrottledDebugSpans.Inc(1)
-		return false
-	}
-	t.credits[operation] = credits - minimumCredits
-	return true
-}
-
-func (t *Throttler) pollManager() {
-	defer t.stopped.Done()
-	ticker := time.NewTicker(t.refreshInterval)
-	defer ticker.Stop()
-	for {
-		select {
-		case <-ticker.C:
-			t.refreshCredits()
-		case <-t.close:
-			return
-		}
-	}
-}
-
-func (t *Throttler) operations() []string {
-	t.mux.RLock()
-	defer t.mux.RUnlock()
-	operations := make([]string, 0, len(t.credits))
-	for op := range t.credits {
-		operations = append(operations, op)
-	}
-	return operations
-}
-
-func (t *Throttler) refreshCredits() {
-	operations := t.operations()
-	if len(operations) == 0 {
-		return
-	}
-	newCredits, err := t.fetchCredits(operations)
-	if err != nil {
-		t.metrics.ThrottlerUpdateFailure.Inc(1)
-		t.logger.Error("Failed to fetch credits: " + err.Error())
-		return
-	}
-	t.metrics.ThrottlerUpdateSuccess.Inc(1)
-
-	t.mux.Lock()
-	defer t.mux.Unlock()
-	for _, opBalance := range newCredits.Balances {
-		t.credits[opBalance.Operation] += opBalance.Balance
-	}
-}
-
-func (t *Throttler) fetchCredits(operations []string) (*creditResponse, error) {
-	uuid := t.uuid.Load()
-	uuidStr, _ := uuid.(string)
-	if uuid == nil || uuidStr == "" {
-		return nil, errorUUIDNotSet
-	}
-	return t.creditManager.FetchCredits(uuidStr, t.service, operations)
-}

vendor/github.com/uber/jaeger-client-go/internal/throttler/throttler.go

@@ -1,32 +0,0 @@
-// Copyright (c) 2018 The Jaeger 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 throttler
-
-// Throttler is used to rate limits operations. For example, given how debug spans
-// are always sampled, a throttler can be enabled per client to rate limit the amount
-// of debug spans a client can start.
-type Throttler interface {
-	// IsAllowed determines whether the operation should be allowed and not be
-	// throttled.
-	IsAllowed(operation string) bool
-}
-
-// DefaultThrottler doesn't throttle at all.
-type DefaultThrottler struct{}
-
-// IsAllowed implements Throttler#IsAllowed.
-func (t DefaultThrottler) IsAllowed(operation string) bool {
-	return true
-}

vendor/github.com/uber/jaeger-client-go/interop.go

@@ -1,55 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"github.com/opentracing/opentracing-go"
-)
-
-// TODO this file should not be needed after TChannel PR.
-
-type formatKey int
-
-// SpanContextFormat is a constant used as OpenTracing Format.
-// Requires *SpanContext as carrier.
-// This format is intended for interop with TChannel or other Zipkin-like tracers.
-const SpanContextFormat formatKey = iota
-
-type jaegerTraceContextPropagator struct {
-	tracer *Tracer
-}
-
-func (p *jaegerTraceContextPropagator) Inject(
-	ctx SpanContext,
-	abstractCarrier interface{},
-) error {
-	carrier, ok := abstractCarrier.(*SpanContext)
-	if !ok {
-		return opentracing.ErrInvalidCarrier
-	}
-
-	carrier.CopyFrom(&ctx)
-	return nil
-}
-
-func (p *jaegerTraceContextPropagator) Extract(abstractCarrier interface{}) (SpanContext, error) {
-	carrier, ok := abstractCarrier.(*SpanContext)
-	if !ok {
-		return emptyContext, opentracing.ErrInvalidCarrier
-	}
-	ctx := new(SpanContext)
-	ctx.CopyFrom(carrier)
-	return *ctx, nil
-}

vendor/github.com/uber/jaeger-client-go/jaeger_tag.go

@@ -1,84 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"fmt"
-
-	"github.com/opentracing/opentracing-go/log"
-
-	j "github.com/uber/jaeger-client-go/thrift-gen/jaeger"
-)
-
-type tags []*j.Tag
-
-// ConvertLogsToJaegerTags converts log Fields into jaeger tags.
-func ConvertLogsToJaegerTags(logFields []log.Field) []*j.Tag {
-	fields := tags(make([]*j.Tag, 0, len(logFields)))
-	for _, field := range logFields {
-		field.Marshal(&fields)
-	}
-	return fields
-}
-
-func (t *tags) EmitString(key, value string) {
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_STRING, VStr: &value})
-}
-
-func (t *tags) EmitBool(key string, value bool) {
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_BOOL, VBool: &value})
-}
-
-func (t *tags) EmitInt(key string, value int) {
-	vLong := int64(value)
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_LONG, VLong: &vLong})
-}
-
-func (t *tags) EmitInt32(key string, value int32) {
-	vLong := int64(value)
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_LONG, VLong: &vLong})
-}
-
-func (t *tags) EmitInt64(key string, value int64) {
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_LONG, VLong: &value})
-}
-
-func (t *tags) EmitUint32(key string, value uint32) {
-	vLong := int64(value)
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_LONG, VLong: &vLong})
-}
-
-func (t *tags) EmitUint64(key string, value uint64) {
-	vLong := int64(value)
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_LONG, VLong: &vLong})
-}
-
-func (t *tags) EmitFloat32(key string, value float32) {
-	vDouble := float64(value)
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_DOUBLE, VDouble: &vDouble})
-}
-
-func (t *tags) EmitFloat64(key string, value float64) {
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_DOUBLE, VDouble: &value})
-}
-
-func (t *tags) EmitObject(key string, value interface{}) {
-	vStr := fmt.Sprintf("%+v", value)
-	*t = append(*t, &j.Tag{Key: key, VType: j.TagType_STRING, VStr: &vStr})
-}
-
-func (t *tags) EmitLazyLogger(value log.LazyLogger) {
-	value(t)
-}

vendor/github.com/uber/jaeger-client-go/jaeger_thrift_span.go

@@ -1,181 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"time"
-
-	"github.com/opentracing/opentracing-go"
-
-	j "github.com/uber/jaeger-client-go/thrift-gen/jaeger"
-	"github.com/uber/jaeger-client-go/utils"
-)
-
-// BuildJaegerThrift builds jaeger span based on internal span.
-// TODO: (breaking change) move to internal package.
-func BuildJaegerThrift(span *Span) *j.Span {
-	span.Lock()
-	defer span.Unlock()
-	startTime := utils.TimeToMicrosecondsSinceEpochInt64(span.startTime)
-	duration := span.duration.Nanoseconds() / int64(time.Microsecond)
-	jaegerSpan := &j.Span{
-		TraceIdLow:    int64(span.context.traceID.Low),
-		TraceIdHigh:   int64(span.context.traceID.High),
-		SpanId:        int64(span.context.spanID),
-		ParentSpanId:  int64(span.context.parentID),
-		OperationName: span.operationName,
-		Flags:         int32(span.context.samplingState.flags()),
-		StartTime:     startTime,
-		Duration:      duration,
-		Tags:          buildTags(span.tags, span.tracer.options.maxTagValueLength),
-		Logs:          buildLogs(span.logs),
-		References:    buildReferences(span.references),
-	}
-	return jaegerSpan
-}
-
-// BuildJaegerProcessThrift creates a thrift Process type.
-// TODO: (breaking change) move to internal package.
-func BuildJaegerProcessThrift(span *Span) *j.Process {
-	span.Lock()
-	defer span.Unlock()
-	return buildJaegerProcessThrift(span.tracer)
-}
-
-func buildJaegerProcessThrift(tracer *Tracer) *j.Process {
-	process := &j.Process{
-		ServiceName: tracer.serviceName,
-		Tags:        buildTags(tracer.tags, tracer.options.maxTagValueLength),
-	}
-	if tracer.process.UUID != "" {
-		process.Tags = append(process.Tags, &j.Tag{Key: TracerUUIDTagKey, VStr: &tracer.process.UUID, VType: j.TagType_STRING})
-	}
-	return process
-}
-
-func buildTags(tags []Tag, maxTagValueLength int) []*j.Tag {
-	jTags := make([]*j.Tag, 0, len(tags))
-	for _, tag := range tags {
-		jTag := buildTag(&tag, maxTagValueLength)
-		jTags = append(jTags, jTag)
-	}
-	return jTags
-}
-
-func buildLogs(logs []opentracing.LogRecord) []*j.Log {
-	jLogs := make([]*j.Log, 0, len(logs))
-	for _, log := range logs {
-		jLog := &j.Log{
-			Timestamp: utils.TimeToMicrosecondsSinceEpochInt64(log.Timestamp),
-			Fields:    ConvertLogsToJaegerTags(log.Fields),
-		}
-		jLogs = append(jLogs, jLog)
-	}
-	return jLogs
-}
-
-func buildTag(tag *Tag, maxTagValueLength int) *j.Tag {
-	jTag := &j.Tag{Key: tag.key}
-	switch value := tag.value.(type) {
-	case string:
-		vStr := truncateString(value, maxTagValueLength)
-		jTag.VStr = &vStr
-		jTag.VType = j.TagType_STRING
-	case []byte:
-		if len(value) > maxTagValueLength {
-			value = value[:maxTagValueLength]
-		}
-		jTag.VBinary = value
-		jTag.VType = j.TagType_BINARY
-	case int:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case uint:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case int8:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case uint8:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case int16:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case uint16:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case int32:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case uint32:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case int64:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case uint64:
-		vLong := int64(value)
-		jTag.VLong = &vLong
-		jTag.VType = j.TagType_LONG
-	case float32:
-		vDouble := float64(value)
-		jTag.VDouble = &vDouble
-		jTag.VType = j.TagType_DOUBLE
-	case float64:
-		vDouble := float64(value)
-		jTag.VDouble = &vDouble
-		jTag.VType = j.TagType_DOUBLE
-	case bool:
-		vBool := value
-		jTag.VBool = &vBool
-		jTag.VType = j.TagType_BOOL
-	default:
-		vStr := truncateString(stringify(value), maxTagValueLength)
-		jTag.VStr = &vStr
-		jTag.VType = j.TagType_STRING
-	}
-	return jTag
-}
-
-func buildReferences(references []Reference) []*j.SpanRef {
-	retMe := make([]*j.SpanRef, 0, len(references))
-	for _, ref := range references {
-		if ref.Type == opentracing.ChildOfRef {
-			retMe = append(retMe, spanRef(ref.Context, j.SpanRefType_CHILD_OF))
-		} else if ref.Type == opentracing.FollowsFromRef {
-			retMe = append(retMe, spanRef(ref.Context, j.SpanRefType_FOLLOWS_FROM))
-		}
-	}
-	return retMe
-}
-
-func spanRef(ctx SpanContext, refType j.SpanRefType) *j.SpanRef {
-	return &j.SpanRef{
-		RefType:     refType,
-		TraceIdLow:  int64(ctx.traceID.Low),
-		TraceIdHigh: int64(ctx.traceID.High),
-		SpanId:      int64(ctx.spanID),
-	}
-}

vendor/github.com/uber/jaeger-client-go/log/logger.go

@@ -1,141 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 log
-
-import (
-	"bytes"
-	"fmt"
-	"log"
-	"sync"
-)
-
-// Logger provides an abstract interface for logging from Reporters.
-// Applications can provide their own implementation of this interface to adapt
-// reporters logging to whatever logging library they prefer (stdlib log,
-// logrus, go-logging, etc).
-type Logger interface {
-	// Error logs a message at error priority
-	Error(msg string)
-
-	// Infof logs a message at info priority
-	Infof(msg string, args ...interface{})
-}
-
-// StdLogger is implementation of the Logger interface that delegates to default `log` package
-var StdLogger = &stdLogger{}
-
-type stdLogger struct{}
-
-func (l *stdLogger) Error(msg string) {
-	log.Printf("ERROR: %s", msg)
-}
-
-// Infof logs a message at info priority
-func (l *stdLogger) Infof(msg string, args ...interface{}) {
-	log.Printf(msg, args...)
-}
-
-// Debugf logs a message at debug priority
-func (l *stdLogger) Debugf(msg string, args ...interface{}) {
-	log.Printf(fmt.Sprintf("DEBUG: %s", msg), args...)
-}
-
-// NullLogger is implementation of the Logger interface that is no-op
-var NullLogger = &nullLogger{}
-
-type nullLogger struct{}
-
-func (l *nullLogger) Error(msg string)                       {}
-func (l *nullLogger) Infof(msg string, args ...interface{})  {}
-func (l *nullLogger) Debugf(msg string, args ...interface{}) {}
-
-// BytesBufferLogger implements Logger backed by a bytes.Buffer.
-type BytesBufferLogger struct {
-	mux sync.Mutex
-	buf bytes.Buffer
-}
-
-// Error implements Logger.
-func (l *BytesBufferLogger) Error(msg string) {
-	l.mux.Lock()
-	l.buf.WriteString(fmt.Sprintf("ERROR: %s\n", msg))
-	l.mux.Unlock()
-}
-
-// Infof implements Logger.
-func (l *BytesBufferLogger) Infof(msg string, args ...interface{}) {
-	l.mux.Lock()
-	l.buf.WriteString("INFO: " + fmt.Sprintf(msg, args...) + "\n")
-	l.mux.Unlock()
-}
-
-// Debugf implements Logger.
-func (l *BytesBufferLogger) Debugf(msg string, args ...interface{}) {
-	l.mux.Lock()
-	l.buf.WriteString("DEBUG: " + fmt.Sprintf(msg, args...) + "\n")
-	l.mux.Unlock()
-}
-
-// String returns string representation of the underlying buffer.
-func (l *BytesBufferLogger) String() string {
-	l.mux.Lock()
-	defer l.mux.Unlock()
-	return l.buf.String()
-}
-
-// Flush empties the underlying buffer.
-func (l *BytesBufferLogger) Flush() {
-	l.mux.Lock()
-	defer l.mux.Unlock()
-	l.buf.Reset()
-}
-
-// DebugLogger is an interface which adds a debug logging level
-type DebugLogger interface {
-	Logger
-
-	// Debugf logs a message at debug priority
-	Debugf(msg string, args ...interface{})
-}
-
-// DebugLogAdapter is a log adapter that converts a Logger into a DebugLogger
-// If the provided Logger doesn't satisfy the interface, a logger with debug
-// disabled is returned
-func DebugLogAdapter(logger Logger) DebugLogger {
-	if logger == nil {
-		return nil
-	}
-	if debugLogger, ok := logger.(DebugLogger); ok {
-		return debugLogger
-	}
-	logger.Infof("debug logging disabled")
-	return debugDisabledLogAdapter{logger: logger}
-}
-
-type debugDisabledLogAdapter struct {
-	logger Logger
-}
-
-func (d debugDisabledLogAdapter) Error(msg string) {
-	d.logger.Error(msg)
-}
-
-func (d debugDisabledLogAdapter) Infof(msg string, args ...interface{}) {
-	d.logger.Infof(msg, args...)
-}
-
-// Debugf is a nop
-func (d debugDisabledLogAdapter) Debugf(msg string, args ...interface{}) {
-}

vendor/github.com/uber/jaeger-client-go/logger.go

@@ -1,53 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import "log"
-
-// NB This will be deprecated in 3.0.0, please use jaeger-client-go/log/logger instead.
-
-// Logger provides an abstract interface for logging from Reporters.
-// Applications can provide their own implementation of this interface to adapt
-// reporters logging to whatever logging library they prefer (stdlib log,
-// logrus, go-logging, etc).
-type Logger interface {
-	// Error logs a message at error priority
-	Error(msg string)
-
-	// Infof logs a message at info priority
-	Infof(msg string, args ...interface{})
-}
-
-// StdLogger is implementation of the Logger interface that delegates to default `log` package
-var StdLogger = &stdLogger{}
-
-type stdLogger struct{}
-
-func (l *stdLogger) Error(msg string) {
-	log.Printf("ERROR: %s", msg)
-}
-
-// Infof logs a message at info priority
-func (l *stdLogger) Infof(msg string, args ...interface{}) {
-	log.Printf(msg, args...)
-}
-
-// NullLogger is implementation of the Logger interface that delegates to default `log` package
-var NullLogger = &nullLogger{}
-
-type nullLogger struct{}
-
-func (l *nullLogger) Error(msg string)                      {}
-func (l *nullLogger) Infof(msg string, args ...interface{}) {}

vendor/github.com/uber/jaeger-client-go/metrics.go

@@ -1,119 +0,0 @@
-// Copyright (c) 2017-2018 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"github.com/uber/jaeger-lib/metrics"
-)
-
-// Metrics is a container of all stats emitted by Jaeger tracer.
-type Metrics struct {
-	// Number of traces started by this tracer as sampled
-	TracesStartedSampled metrics.Counter `metric:"traces" tags:"state=started,sampled=y" help:"Number of traces started by this tracer as sampled"`
-
-	// Number of traces started by this tracer as not sampled
-	TracesStartedNotSampled metrics.Counter `metric:"traces" tags:"state=started,sampled=n" help:"Number of traces started by this tracer as not sampled"`
-
-	// Number of traces started by this tracer with delayed sampling
-	TracesStartedDelayedSampling metrics.Counter `metric:"traces" tags:"state=started,sampled=n" help:"Number of traces started by this tracer with delayed sampling"`
-
-	// Number of externally started sampled traces this tracer joined
-	TracesJoinedSampled metrics.Counter `metric:"traces" tags:"state=joined,sampled=y" help:"Number of externally started sampled traces this tracer joined"`
-
-	// Number of externally started not-sampled traces this tracer joined
-	TracesJoinedNotSampled metrics.Counter `metric:"traces" tags:"state=joined,sampled=n" help:"Number of externally started not-sampled traces this tracer joined"`
-
-	// Number of sampled spans started by this tracer
-	SpansStartedSampled metrics.Counter `metric:"started_spans" tags:"sampled=y" help:"Number of spans started by this tracer as sampled"`
-
-	// Number of not sampled spans started by this tracer
-	SpansStartedNotSampled metrics.Counter `metric:"started_spans" tags:"sampled=n" help:"Number of spans started by this tracer as not sampled"`
-
-	// Number of spans with delayed sampling started by this tracer
-	SpansStartedDelayedSampling metrics.Counter `metric:"started_spans" tags:"sampled=delayed" help:"Number of spans started by this tracer with delayed sampling"`
-
-	// Number of spans finished by this tracer
-	SpansFinishedSampled metrics.Counter `metric:"finished_spans" tags:"sampled=y" help:"Number of sampled spans finished by this tracer"`
-
-	// Number of spans finished by this tracer
-	SpansFinishedNotSampled metrics.Counter `metric:"finished_spans" tags:"sampled=n" help:"Number of not-sampled spans finished by this tracer"`
-
-	// Number of spans finished by this tracer
-	SpansFinishedDelayedSampling metrics.Counter `metric:"finished_spans" tags:"sampled=delayed" help:"Number of spans with delayed sampling finished by this tracer"`
-
-	// Number of errors decoding tracing context
-	DecodingErrors metrics.Counter `metric:"span_context_decoding_errors" help:"Number of errors decoding tracing context"`
-
-	// Number of spans successfully reported
-	ReporterSuccess metrics.Counter `metric:"reporter_spans" tags:"result=ok" help:"Number of spans successfully reported"`
-
-	// Number of spans not reported due to a Sender failure
-	ReporterFailure metrics.Counter `metric:"reporter_spans" tags:"result=err" help:"Number of spans not reported due to a Sender failure"`
-
-	// Number of spans dropped due to internal queue overflow
-	ReporterDropped metrics.Counter `metric:"reporter_spans" tags:"result=dropped" help:"Number of spans dropped due to internal queue overflow"`
-
-	// Current number of spans in the reporter queue
-	ReporterQueueLength metrics.Gauge `metric:"reporter_queue_length" help:"Current number of spans in the reporter queue"`
-
-	// Number of times the Sampler succeeded to retrieve sampling strategy
-	SamplerRetrieved metrics.Counter `metric:"sampler_queries" tags:"result=ok" help:"Number of times the Sampler succeeded to retrieve sampling strategy"`
-
-	// Number of times the Sampler failed to retrieve sampling strategy
-	SamplerQueryFailure metrics.Counter `metric:"sampler_queries" tags:"result=err" help:"Number of times the Sampler failed to retrieve sampling strategy"`
-
-	// Number of times the Sampler succeeded to retrieve and update sampling strategy
-	SamplerUpdated metrics.Counter `metric:"sampler_updates" tags:"result=ok" help:"Number of times the Sampler succeeded to retrieve and update sampling strategy"`
-
-	// Number of times the Sampler failed to update sampling strategy
-	SamplerUpdateFailure metrics.Counter `metric:"sampler_updates" tags:"result=err" help:"Number of times the Sampler failed to update sampling strategy"`
-
-	// Number of times baggage was successfully written or updated on spans.
-	BaggageUpdateSuccess metrics.Counter `metric:"baggage_updates" tags:"result=ok" help:"Number of times baggage was successfully written or updated on spans"`
-
-	// Number of times baggage failed to write or update on spans.
-	BaggageUpdateFailure metrics.Counter `metric:"baggage_updates" tags:"result=err" help:"Number of times baggage failed to write or update on spans"`
-
-	// Number of times baggage was truncated as per baggage restrictions.
-	BaggageTruncate metrics.Counter `metric:"baggage_truncations" help:"Number of times baggage was truncated as per baggage restrictions"`
-
-	// Number of times baggage restrictions were successfully updated.
-	BaggageRestrictionsUpdateSuccess metrics.Counter `metric:"baggage_restrictions_updates" tags:"result=ok" help:"Number of times baggage restrictions were successfully updated"`
-
-	// Number of times baggage restrictions failed to update.
-	BaggageRestrictionsUpdateFailure metrics.Counter `metric:"baggage_restrictions_updates" tags:"result=err" help:"Number of times baggage restrictions failed to update"`
-
-	// Number of times debug spans were throttled.
-	ThrottledDebugSpans metrics.Counter `metric:"throttled_debug_spans" help:"Number of times debug spans were throttled"`
-
-	// Number of times throttler successfully updated.
-	ThrottlerUpdateSuccess metrics.Counter `metric:"throttler_updates" tags:"result=ok" help:"Number of times throttler successfully updated"`
-
-	// Number of times throttler failed to update.
-	ThrottlerUpdateFailure metrics.Counter `metric:"throttler_updates" tags:"result=err" help:"Number of times throttler failed to update"`
-}
-
-// NewMetrics creates a new Metrics struct and initializes it.
-func NewMetrics(factory metrics.Factory, globalTags map[string]string) *Metrics {
-	m := &Metrics{}
-	// TODO the namespace "jaeger" should be configurable
-	metrics.MustInit(m, factory.Namespace(metrics.NSOptions{Name: "jaeger"}).Namespace(metrics.NSOptions{Name: "tracer"}), globalTags)
-	return m
-}
-
-// NewNullMetrics creates a new Metrics struct that won't report any metrics.
-func NewNullMetrics() *Metrics {
-	return NewMetrics(metrics.NullFactory, nil)
-}

vendor/github.com/uber/jaeger-client-go/observer.go

@@ -1,88 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import opentracing "github.com/opentracing/opentracing-go"
-
-// Observer can be registered with the Tracer to receive notifications about
-// new Spans.
-//
-// Deprecated: use jaeger.ContribObserver instead.
-type Observer interface {
-	OnStartSpan(operationName string, options opentracing.StartSpanOptions) SpanObserver
-}
-
-// SpanObserver is created by the Observer and receives notifications about
-// other Span events.
-//
-// Deprecated: use jaeger.ContribSpanObserver instead.
-type SpanObserver interface {
-	OnSetOperationName(operationName string)
-	OnSetTag(key string, value interface{})
-	OnFinish(options opentracing.FinishOptions)
-}
-
-// compositeObserver is a dispatcher to other observers
-type compositeObserver struct {
-	observers []ContribObserver
-}
-
-// compositeSpanObserver is a dispatcher to other span observers
-type compositeSpanObserver struct {
-	observers []ContribSpanObserver
-}
-
-// noopSpanObserver is used when there are no observers registered
-// on the Tracer or none of them returns span observers from OnStartSpan.
-var noopSpanObserver = &compositeSpanObserver{}
-
-func (o *compositeObserver) append(contribObserver ContribObserver) {
-	o.observers = append(o.observers, contribObserver)
-}
-
-func (o *compositeObserver) OnStartSpan(sp opentracing.Span, operationName string, options opentracing.StartSpanOptions) ContribSpanObserver {
-	var spanObservers []ContribSpanObserver
-	for _, obs := range o.observers {
-		spanObs, ok := obs.OnStartSpan(sp, operationName, options)
-		if ok {
-			if spanObservers == nil {
-				spanObservers = make([]ContribSpanObserver, 0, len(o.observers))
-			}
-			spanObservers = append(spanObservers, spanObs)
-		}
-	}
-	if len(spanObservers) == 0 {
-		return noopSpanObserver
-	}
-	return &compositeSpanObserver{observers: spanObservers}
-}
-
-func (o *compositeSpanObserver) OnSetOperationName(operationName string) {
-	for _, obs := range o.observers {
-		obs.OnSetOperationName(operationName)
-	}
-}
-
-func (o *compositeSpanObserver) OnSetTag(key string, value interface{}) {
-	for _, obs := range o.observers {
-		obs.OnSetTag(key, value)
-	}
-}
-
-func (o *compositeSpanObserver) OnFinish(options opentracing.FinishOptions) {
-	for _, obs := range o.observers {
-		obs.OnFinish(options)
-	}
-}

vendor/github.com/uber/jaeger-client-go/propagation.go

@@ -1,325 +0,0 @@
-// Copyright (c) 2017 Uber Technologies, Inc.
-//
-// 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 jaeger
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"log"
-	"net/url"
-	"strings"
-	"sync"
-
-	opentracing "github.com/opentracing/opentracing-go"
-)
-
-// Injector is responsible for injecting SpanContext instances in a manner suitable
-// for propagation via a format-specific "carrier" object. Typically the
-// injection will take place across an RPC boundary, but message queues and
-// other IPC mechanisms are also reasonable places to use an Injector.
-type Injector interface {
-	// Inject takes `SpanContext` and injects it into `carrier`. The actual type
-	// of `carrier` depends on the `format` passed to `Tracer.Inject()`.
-	//
-	// Implementations may return opentracing.ErrInvalidCarrier or any other
-	// implementation-specific error if injection fails.
-	Inject(ctx SpanContext, carrier interface{}) error
-}
-
-// Extractor is responsible for extracting SpanContext instances from a
-// format-specific "carrier" object. Typically the extraction will take place
-// on the server side of an RPC boundary, but message queues and other IPC
-// mechanisms are also reasonable places to use an Extractor.
-type Extractor interface {
-	// Extract decodes a SpanContext instance from the given `carrier`,
-	// or (nil, opentracing.ErrSpanContextNotFound) if no context could
-	// be found in the `carrier`.
-	Extract(carrier interface{}) (SpanContext, error)
-}
-
-// TextMapPropagator is a combined Injector and Extractor for TextMap format
-type TextMapPropagator struct {
-	headerKeys  *HeadersConfig
-	metrics     Metrics
-	encodeValue func(string) string
-	decodeValue func(string) string
-}
-
-// NewTextMapPropagator creates a combined Injector and Extractor for TextMap format
-func NewTextMapPropagator(headerKeys *HeadersConfig, metrics Metrics) *TextMapPropagator {
-	return &TextMapPropagator{
-		headerKeys: headerKeys,
-		metrics:    metrics,
-		encodeValue: func(val string) string {
-			return val
-		},
-		decodeValue: func(val string) string {
-			return val
-		},
-	}
-}
-
-// NewHTTPHeaderPropagator creates a combined Injector and Extractor for HTTPHeaders format
-func NewHTTPHeaderPropagator(headerKeys *HeadersConfig, metrics Metrics) *TextMapPropagator {
-	return &TextMapPropagator{
-		headerKeys: headerKeys,
-		metrics:    metrics,
-		encodeValue: func(val string) string {
-			return url.QueryEscape(val)
-		},
-		decodeValue: func(val string) string {
-			// ignore decoding errors, cannot do anything about them
-			if v, err := url.QueryUnescape(val); err == nil {
-				return v
-			}
-			return val
-		},
-	}
-}
-
-// BinaryPropagator is a combined Injector and Extractor for Binary format
-type BinaryPropagator struct {
-	tracer  *Tracer
-	buffers sync.Pool
-}
-
-// NewBinaryPropagator creates a combined Injector and Extractor for Binary format
-func NewBinaryPropagator(tracer *Tracer) *BinaryPropagator {
-	return &BinaryPropagator{
-		tracer:  tracer,
-		buffers: sync.Pool{New: func() interface{} { return &bytes.Buffer{} }},
-	}
-}
-
-// Inject implements Injector of TextMapPropagator
-func (p *TextMapPropagator) Inject(
-	sc SpanContext,
-	abstractCarrier interface{},
-) error {
-	textMapWriter, ok := abstractCarrier.(opentracing.TextMapWriter)
-	if !ok {
-		return opentracing.ErrInvalidCarrier
-	}
-
-	// Do not encode the string with trace context to avoid accidental double-encoding
-	// if people are using opentracing < 0.10.0. Our colon-separated representation
-	// of the trace context is already safe for HTTP headers.
-	textMapWriter.Set(p.headerKeys.TraceContextHeaderName, sc.String())
-	for k, v := range sc.baggage {
-		safeKey := p.addBaggageKeyPrefix(k)
-		safeVal := p.encodeValue(v)
-		textMapWriter.Set(safeKey, safeVal)
-	}
-	return nil
-}
-
-// Extract implements Extractor of TextMapPropagator
-func (p *TextMapPropagator) Extract(abstractCarrier interface{}) (SpanContext, error) {
-	textMapReader, ok := abstractCarrier.(opentracing.TextMapReader)
-	if !ok {
-		return emptyContext, opentracing.ErrInvalidCarrier
-	}
-	var ctx SpanContext
-	var baggage map[string]string
-	err := textMapReader.ForeachKey(func(rawKey, value string) error {
-		key := strings.ToLower(rawKey) // TODO not necessary for plain TextMap
-		if key == p.headerKeys.TraceContextHeaderName {
-			var err error
-			safeVal := p.decodeValue(value)
-			if ctx, err = ContextFromString(safeVal); err != nil {
-				return err
-			}
-		} else if key == p.headerKeys.JaegerDebugHeader {
-			ctx.debugID = p.decodeValue(value)
-		} else if key == p.headerKeys.JaegerBaggageHeader {
-			if baggage == nil {
-				baggage = make(map[string]string)
-			}
-			for k, v := range p.parseCommaSeparatedMap(value) {
-				baggage[k] = v
-			}
-		} else if strings.HasPrefix(key, p.headerKeys.TraceBaggageHeaderPrefix) {
-			if baggage == nil {
-				baggage = make(map[string]string)
-			}
-			safeKey := p.removeBaggageKeyPrefix(key)
-			safeVal := p.decodeValue(value)
-			baggage[safeKey] = safeVal
-		}
-		return nil
-	})
-	if err != nil {
-		p.metrics.DecodingErrors.Inc(1)
-		return emptyContext, err
-	}
-	if !ctx.traceID.IsValid() && ctx.debugID == "" && len(baggage) == 0 {
-		return emptyContext, opentracing.ErrSpanContextNotFound
-	}
-	ctx.baggage = baggage
-	return ctx, nil
-}
-
-// Inject implements Injector of BinaryPropagator
-func (p *BinaryPropagator) Inject(
-	sc SpanContext,
-	abstractCarrier interface{},
-) error {
-	carrier, ok := abstractCarrier.(io.Writer)
-	if !ok {
-		return opentracing.ErrInvalidCarrier
-	}
-
-	// Handle the tracer context
-	if err := binary.Write(carrier, binary.BigEndian, sc.traceID); err != nil {
-		return err
-	}
-	if err := binary.Write(carrier, binary.BigEndian, sc.spanID); err != nil {
-		return err
-	}
-	if err := binary.Write(carrier, binary.BigEndian, sc.parentID); err != nil {
-		return err
-	}
-	if err := binary.Write(carrier, binary.BigEndian, sc.samplingState.flags()); err != nil {
-		return err
-	}
-
-	// Handle the baggage items
-	if err := binary.Write(carrier, binary.BigEndian, int32(len(sc.baggage))); err != nil {
-		return err
-	}
-	for k, v := range sc.baggage {
-		if err := binary.Write(carrier, binary.BigEndian, int32(len(k))); err != nil {
-			return err
-		}
-		io.WriteString(carrier, k)
-		if err := binary.Write(carrier, binary.BigEndian, int32(len(v))); err != nil {
-			return err
-		}
-		io.WriteString(carrier, v)
-	}
-
-	return nil
-}
-
-// W3C limits https://github.com/w3c/baggage/blob/master/baggage/HTTP_HEADER_FORMAT.md#limits
-const (
-	maxBinaryBaggage      = 180
-	maxBinaryNameValueLen = 4096
-)
-
-// Extract implements Extractor of BinaryPropagator
-func (p *BinaryPropagator) Extract(abstractCarrier interface{}) (SpanContext, error) {
-	carrier, ok := abstractCarrier.(io.Reader)
-	if !ok {
-		return emptyContext, opentracing.ErrInvalidCarrier
-	}
-	var ctx SpanContext
-	ctx.samplingState = &samplingState{}
-
-	if err := binary.Read(carrier, binary.BigEndian, &ctx.traceID); err != nil {
-		return emptyContext, opentracing.ErrSpanContextCorrupted
-	}
-	if err := binary.Read(carrier, binary.BigEndian, &ctx.spanID); err != nil {
-		return emptyContext, opentracing.ErrSpanContextCorrupted
-	}
-	if err := binary.Read(carrier, binary.BigEndian, &ctx.parentID); err != nil {
-		return emptyContext, opentracing.ErrSpanContextCorrupted
-	}
-
-	var flags byte
-	if err := binary.Read(carrier, binary.BigEndian, &flags); err != nil {
-		return emptyContext, opentracing.ErrSpanContextCorrupted
-	}
-	ctx.samplingState.setFlags(flags)
-
-	// Handle the baggage items
-	var numBaggage int32
-	if err := binary.Read(carrier, binary.BigEndian, &numBaggage); err != nil {
-		return emptyContext, opentracing.ErrSpanContextCorrupted
-	}
-	if numBaggage > maxBinaryBaggage {
-		return emptyContext, opentracing.ErrSpanContextCorrupted
-	}
-	if iNumBaggage := int(numBaggage); iNumBaggage > 0 {
-		ctx.baggage = make(map[string]string, iNumBaggage)
-		buf := p.buffers.Get().(*bytes.Buffer)
-		defer p.buffers.Put(buf)
-
-		var keyLen, valLen int32
-		for i := 0; i < iNumBaggage; i++ {
-			if err := binary.Read(carrier, binary.BigEndian, &keyLen); err != nil {
-				return emptyContext, opentracing.ErrSpanContextCorrupted
-			}
-			buf.Reset()
-			buf.Grow(int(keyLen))
-			if n, err := io.CopyN(buf, carrier, int64(keyLen)); err != nil || int32(n) != keyLen {
-				return emptyContext, opentracing.ErrSpanContextCorrupted
-			}
-			key := buf.String()
-
-			if err := binary.Read(carrier, binary.BigEndian, &valLen); err != nil {
-				return emptyContext, opentracing.ErrSpanContextCorrupted
-			}
-			if keyLen+valLen > maxBinaryNameValueLen {
-				return emptyContext, opentracing.ErrSpanContextCorrupted
-			}
-			buf.Reset()
-			buf.Grow(int(valLen))
-			if n, err := io.CopyN(buf, carrier, int64(valLen)); err != nil || int32(n) != valLen {
-				return emptyContext, opentracing.ErrSpanContextCorrupted
-			}
-			ctx.baggage[key] = buf.String()
-		}
-	}
-
-	return ctx, nil
-}
-
-// Converts a comma separated key value pair list into a map
-// e.g. key1=value1, key2=value2, key3 = value3
-// is converted to map[string]string { "key1" : "value1",
-//                                     "key2" : "value2",
-//                                     "key3" : "value3" }
-func (p *TextMapPropagator) parseCommaSeparatedMap(value string) map[string]string {
-	baggage := make(map[string]string)
-	value, err := url.QueryUnescape(value)
-	if err != nil {
-		log.Printf("Unable to unescape %s, %v", value, err)
-		return baggage
-	}
-	for _, kvpair := range strings.Split(value, ",") {
-		kv := strings.Split(strings.TrimSpace(kvpair), "=")
-		if len(kv) == 2 {
-			baggage[strings.TrimSpace(kv[0])] = kv[1]
-		} else {
-			log.Printf("Malformed value passed in for %s", p.headerKeys.JaegerBaggageHeader)
-		}
-	}
-	return baggage
-}
-
-// Converts a baggage item key into an http header format,
-// by prepending TraceBaggageHeaderPrefix and encoding the key string
-func (p *TextMapPropagator) addBaggageKeyPrefix(key string) string {
-	// TODO encodeBaggageKeyAsHeader add caching and escaping
-	return fmt.Sprintf("%v%v", p.headerKeys.TraceBaggageHeaderPrefix, key)
-}
-
-func (p *TextMapPropagator) removeBaggageKeyPrefix(key string) string {
-	// TODO decodeBaggageHeaderKey add caching and escaping
-	return key[len(p.headerKeys.TraceBaggageHeaderPrefix):]
-}