Add ai3/go-common/tracing and deps

vendor/git.autistici.org/ai3/go-common/tracing/tracing.go

+package tracing
+
+import (
+	"encoding/json"
+	"errors"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"strconv"
+	"sync"
+
+	openzipkin "github.com/openzipkin/zipkin-go"
+	zipkinHTTP "github.com/openzipkin/zipkin-go/reporter/http"
+	"go.opencensus.io/exporter/zipkin"
+	"go.opencensus.io/plugin/ochttp"
+	"go.opencensus.io/trace"
+)
+
+var (
+	// Enabled reports whether tracing is globally enabled or not.
+	Enabled bool
+
+	// The active tracing configuration, if Enabled is true.
+	config tracingConfig
+
+	initOnce sync.Once
+)
+
+const globalTracingConfigPath = "/etc/tracing/client.conf"
+
+type tracingConfig struct {
+	ReportURL string `json:"report_url"`
+	Sample    string `json:"sample"`
+}
+
+// Read the global tracing configuration file. Its location is
+// hardcoded, but it can be overriden using the TRACING_CONFIG
+// environment variable.
+func readTracingConfig() error {
+	// Read and decode configuration.
+	cfgPath := globalTracingConfigPath
+	if s := os.Getenv("TRACING_CONFIG"); s != "" {
+		cfgPath = s
+	}
+	data, err := ioutil.ReadFile(cfgPath)
+	if err != nil {
+		return err
+	}
+
+	if err := json.Unmarshal(data, &config); err != nil {
+		log.Printf("warning: error in tracing configuration: %v, tracing disabled", err)
+		return err
+	}
+
+	if config.ReportURL == "" {
+		log.Printf("warning: tracing configuration contains no report_url, tracing disabled")
+		return errors.New("no report_url")
+	}
+
+	return nil
+}
+
+// Compute the service name for Zipkin: this is usually the program
+// name (without path), but it can be overriden by the TRACING_SERVICE
+// environment variable.
+func getServiceName() string {
+	if s := os.Getenv("TRACING_SERVICE"); s != "" {
+		return s
+	}
+	return filepath.Base(os.Args[0])
+}
+
+// Initialize tracing. Tracing will be enabled if the system-wide
+// tracing configuration file is present and valid. Explicitly set
+// TRACING_ENABLE=0 in the environment to disable tracing.
+//
+// We need to check the configuration as soon as possible, because
+// it's likely that client transports are created before HTTP servers,
+// and we need to wrap them with opencensus at creation time.
+func init() {
+	// Kill switch from environment.
+	if s := os.Getenv("TRACING_ENABLE"); s == "0" {
+		return
+	}
+
+	if err := readTracingConfig(); err != nil {
+		return
+	}
+
+	Enabled = true
+}
+
+func initTracing(endpointAddr string) {
+	if !Enabled {
+		return
+	}
+	initOnce.Do(func() {
+		localEndpoint, err := openzipkin.NewEndpoint(getServiceName(), endpointAddr)
+		if err != nil {
+			log.Printf("warning: error creating tracing endpoint: %v, tracing disabled", err)
+			return
+		}
+
+		reporter := zipkinHTTP.NewReporter(config.ReportURL)
+		ze := zipkin.NewExporter(reporter, localEndpoint)
+		trace.RegisterExporter(ze)
+
+		var tc trace.Config
+		switch config.Sample {
+		case "", "always":
+			tc.DefaultSampler = trace.AlwaysSample()
+		case "never":
+			tc.DefaultSampler = trace.NeverSample()
+		default:
+			frac, err := strconv.ParseFloat(config.Sample, 64)
+			if err != nil {
+				log.Printf("warning: error in tracing configuration: sample: %v, tracing disabled", err)
+				return
+			}
+			tc.DefaultSampler = trace.ProbabilitySampler(frac)
+		}
+		trace.ApplyConfig(tc)
+
+		log.Printf("tracing enabled (report_url %s)", config.ReportURL)
+
+		Enabled = true
+	})
+}
+
+// Init tracing support, if not using WrapHandler.
+func Init() {
+	initTracing("")
+}
+
+// WrapTransport optionally wraps a http.RoundTripper with OpenCensus
+// tracing functionality, if it is globally enabled.
+func WrapTransport(t http.RoundTripper) http.RoundTripper {
+	if Enabled {
+		t = &ochttp.Transport{Base: t}
+	}
+	return t
+}
+
+// WrapHandler wraps a http.Handler with OpenCensus tracing
+// functionality, if globally enabled. Automatically calls Init().
+func WrapHandler(h http.Handler, endpointAddr string) http.Handler {
+	if Enabled {
+		initTracing(endpointAddr)
+		h = &ochttp.Handler{Handler: h}
+	}
+	return h
+}

vendor/github.com/openzipkin/zipkin-go/LICENSE

+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "{}"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright 2017 The OpenZipkin 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.

vendor/github.com/openzipkin/zipkin-go/Makefile

+
+.DEFAULT_GOAL := test
+
+.PHONY: test
+test:
+	go test -v -race -cover ./...
+
+.PHONY: bench
+bench:
+	go test -v -run - -bench . -benchmem ./...
+
+.PHONY: protoc
+protoc:
+	protoc --go_out=. proto/v2/zipkin.proto
+
+.PHONY: lint
+lint:
+	# Ignore grep's exit code since no match returns 1.
+	-if [[ ! $TRAVIS_GO_VERSION = 1.8* ]]; then echo 'linting...' ; golint ./... ; fi
+
+.PHONY: vet
+vet:
+	go vet ./...
+
+.PHONY: all
+all: vet lint test bench
+
+.PHONY: example

vendor/github.com/openzipkin/zipkin-go/README.md

+# Zipkin Library for Go
+
+[![Travis CI](https://travis-ci.org/openzipkin/zipkin-go.svg?branch=master)](https://travis-ci.org/openzipkin/zipkin-go)
+[![CircleCI](https://circleci.com/gh/openzipkin/zipkin-go.svg?style=shield)](https://circleci.com/gh/openzipkin/zipkin-go)
+[![Appveyor CI](https://ci.appveyor.com/api/projects/status/1d0e5k96g10ajl63/branch/master?svg=true)](https://ci.appveyor.com/project/basvanbeek/zipkin-go)
+[![Coverage Status](https://img.shields.io/coveralls/github/openzipkin/zipkin-go.svg)](https://coveralls.io/github/openzipkin/zipkin-go?branch=master)
+[![Go Report Card](https://goreportcard.com/badge/github.com/openzipkin/zipkin-go)](https://goreportcard.com/report/github.com/openzipkin/zipkin-go)
+[![GoDoc](https://godoc.org/github.com/openzipkin/zipkin-go?status.svg)](https://godoc.org/github.com/openzipkin/zipkin-go)
+[![Gitter chat](https://badges.gitter.im/openzipkin/zipkin.svg)](https://gitter.im/openzipkin/zipkin?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![Sourcegraph](https://sourcegraph.com/github.com/openzipkin/zipkin-go/-/badge.svg)](https://sourcegraph.com/github.com/openzipkin/zipkin-go?badge)
+
+Zipkin Go is the official Go Tracer implementation for Zipkin, supported by the
+OpenZipkin community.
+
+## package organization
+`zipkin-go` is built with interoperability in mind within the OpenZipkin
+community and even 3rd parties, the library consists of several packages.
+
+The main tracing implementation can be found in the root folder of this
+repository. Reusable parts not considered core implementation or deemed
+beneficiary for usage by others are placed in their own packages within this
+repository.
+
+### model
+This library implements the Zipkin V2 Span Model which is available in the model
+package. It contains a Go data model compatible with the Zipkin V2 API and can
+automatically sanitize, parse and (de)serialize to and from the required JSON
+representation as used by the official Zipkin V2 Collectors.
+
+### propagation
+The propagation package and B3 subpackage hold the logic for propagating
+SpanContext (span identifiers and sampling flags) between services participating
+in traces. Currently Zipkin B3 Propagation is supported for HTTP and GRPC.
+
+### middleware
+The middleware subpackages contain officially supported middleware handlers and
+tracing wrappers.
+
+#### http
+An easy to use http.Handler middleware for tracing server side requests is
+provided. This allows one to use this middleware in applications using
+standard library servers as well as most available higher level frameworks. Some
+frameworks will have their own instrumentation and middleware that maps better
+for their ecosystem.
+
+For HTTP client operations `NewTransport` can return a `http.RoundTripper`
+implementation that can either wrap the standard http.Client's Transport or a
+custom provided one and add per request tracing. Since HTTP Requests can have
+one or multiple redirects it is advisable to always enclose HTTP Client calls
+with a `Span` either around the `*http.Client` call level or parent function
+level.
+
+For convenience `NewClient` is provided which returns a HTTP Client which embeds
+`*http.Client` and provides an `application span` around the HTTP calls when
+calling the `DoWithAppSpan()` method.
+
+#### grpc
+gRPC middleware / interceptors are planned for the near future.
+
+### reporter
+The reporter package holds the interface which the various Reporter
+implementations use. It is exported into its own package as it can be used by
+3rd parties to use these Reporter packages in their own libraries for exporting
+to the Zipkin ecosystem. The `zipkin-go` tracer also uses the interface to
+accept 3rd party Reporter implementations.
+
+#### HTTP Reporter
+Most common Reporter type used by Zipkin users transporting Spans to the Zipkin
+server using JSON over HTTP. The reporter holds a buffer and reports to the
+backend asynchronously.
+
+#### Kafka Reporter
+High performance Reporter transporting Spans to the Zipkin server using a Kafka
+Producer digesting JSON V2 Spans. The reporter uses the
+[Sarama async producer](https://godoc.org/github.com/Shopify/sarama#AsyncProducer)
+underneath.
+
+## usage and examples
+[HTTP Server Example](example_httpserver_test.go)

vendor/github.com/openzipkin/zipkin-go/appveyor.yml

+version: v1.0.0.{build}
+
+platform: x64
+
+clone_folder: c:\gopath\src\github.com\openzipkin\zipkin-go
+
+environment:
+  GOPATH: c:\gopath
+
+install:
+  - echo %PATH%
+  - echo %GOPATH%
+  - set PATH=%GOPATH%\bin;c:\go\bin;%PATH%
+  - go version
+  - go env
+
+build_script:
+  - go get -t -v ./...
+  - go vet ./...
+  - go test -v -race -cover ./...
+  - go test -v -run - -bench . -benchmem ./...

vendor/github.com/openzipkin/zipkin-go/circle.yml

+version: 2
+jobs:
+  build:
+    working_directory: /go/src/github.com/openzipkin/zipkin-go
+    parallelism: 1
+    docker:
+      - image: circleci/golang
+    steps:
+      - checkout
+      - run: go get -t -v -d ./...
+      - run: make vet test bench

vendor/github.com/openzipkin/zipkin-go/context.go

+package zipkin
+
+import (
+	"context"
+)
+
+// SpanFromContext retrieves a Zipkin Span from Go's context propagation
+// mechanism if found. If not found, returns nil.
+func SpanFromContext(ctx context.Context) Span {
+	if s, ok := ctx.Value(spanKey).(Span); ok {
+		return s
+	}
+	return nil
+}
+
+// NewContext stores a Zipkin Span into Go's context propagation mechanism.
+func NewContext(ctx context.Context, s Span) context.Context {
+	return context.WithValue(ctx, spanKey, s)
+}
+
+type ctxKey struct{}
+
+var spanKey = ctxKey{}

vendor/github.com/openzipkin/zipkin-go/doc.go

+/*
+Package zipkin implements a native Zipkin instrumentation library for Go.
+
+See https://zipkin.io for more information about Zipkin.
+*/
+package zipkin

vendor/github.com/openzipkin/zipkin-go/endpoint.go

+package zipkin
+
+import (
+	"net"
+	"strconv"
+	"strings"
+
+	"github.com/openzipkin/zipkin-go/model"
+)
+
+// NewEndpoint creates a new endpoint given the provided serviceName and
+// hostPort.
+func NewEndpoint(serviceName string, hostPort string) (*model.Endpoint, error) {
+	e := &model.Endpoint{
+		ServiceName: serviceName,
+	}
+
+	if hostPort == "" || hostPort == ":0" {
+		if serviceName == "" {
+			// if all properties are empty we should not have an Endpoint object.
+			return nil, nil
+		}
+		return e, nil
+	}
+
+	if strings.IndexByte(hostPort, ':') < 0 {
+		hostPort += ":0"
+	}
+
+	host, port, err := net.SplitHostPort(hostPort)
+	if err != nil {
+		return nil, err
+	}
+
+	p, err := strconv.ParseUint(port, 10, 16)
+	if err != nil {
+		return nil, err
+	}
+	e.Port = uint16(p)
+
+	addrs, err := net.LookupIP(host)
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range addrs {
+		addr := addrs[i].To4()
+		if addr == nil {
+			// IPv6 - 16 bytes
+			if e.IPv6 == nil {
+				e.IPv6 = addrs[i].To16()
+			}
+		} else {
+			// IPv4 - 4 bytes
+			if e.IPv4 == nil {
+				e.IPv4 = addr
+			}
+		}
+		if e.IPv4 != nil && e.IPv6 != nil {
+			// Both IPv4 & IPv6 have been set, done...
+			break
+		}
+	}
+
+	return e, nil
+}

vendor/github.com/openzipkin/zipkin-go/idgenerator/idgenerator.go

+/*
+Package idgenerator contains several Span and Trace ID generators which can be
+used by the Zipkin tracer. Additional third party generators can be plugged in
+if they adhere to the IDGenerator interface.
+*/
+package idgenerator
+
+import (
+	"math/rand"
+	"sync"
+	"time"
+
+	"github.com/openzipkin/zipkin-go/model"
+)
+
+var (
+	seededIDGen = rand.New(rand.NewSource(time.Now().UnixNano()))
+	// NewSource returns a new pseudo-random Source seeded with the given value.
+	// Unlike the default Source used by top-level functions, this source is not
+	// safe for concurrent use by multiple goroutines. Hence the need for a mutex.
+	seededIDLock sync.Mutex
+)
+
+// IDGenerator interface can be used to provide the Zipkin Tracer with custom
+// implementations to generate Span and Trace IDs.
+type IDGenerator interface {
+	SpanID(traceID model.TraceID) model.ID // Generates a new Span ID
+	TraceID() model.TraceID                // Generates a new Trace ID
+}
+
+// NewRandom64 returns an ID Generator which can generate 64 bit trace and span
+// id's
+func NewRandom64() IDGenerator {
+	return &randomID64{}
+}
+
+// NewRandom128 returns an ID Generator which can generate 128 bit trace and 64
+// bit span id's
+func NewRandom128() IDGenerator {
+	return &randomID128{}
+}
+
+// NewRandomTimestamped generates 128 bit time sortable traceid's and 64 bit
+// spanid's.
+func NewRandomTimestamped() IDGenerator {
+	return &randomTimestamped{}
+}
+
+// randomID64 can generate 64 bit traceid's and 64 bit spanid's.
+type randomID64 struct{}
+
+func (r *randomID64) TraceID() (id model.TraceID) {
+	seededIDLock.Lock()
+	id = model.TraceID{
+		Low: uint64(seededIDGen.Int63()),
+	}
+	seededIDLock.Unlock()
+	return
+}
+
+func (r *randomID64) SpanID(traceID model.TraceID) (id model.ID) {
+	if !traceID.Empty() {
+		return model.ID(traceID.Low)
+	}
+	seededIDLock.Lock()
+	id = model.ID(seededIDGen.Int63())
+	seededIDLock.Unlock()
+	return
+}
+
+// randomID128 can generate 128 bit traceid's and 64 bit spanid's.
+type randomID128 struct{}
+
+func (r *randomID128) TraceID() (id model.TraceID) {
+	seededIDLock.Lock()
+	id = model.TraceID{
+		High: uint64(seededIDGen.Int63()),
+		Low:  uint64(seededIDGen.Int63()),
+	}
+	seededIDLock.Unlock()
+	return
+}
+
+func (r *randomID128) SpanID(traceID model.TraceID) (id model.ID) {
+	if !traceID.Empty() {
+		return model.ID(traceID.Low)
+	}
+	seededIDLock.Lock()
+	id = model.ID(seededIDGen.Int63())
+	seededIDLock.Unlock()
+	return
+}
+
+// randomTimestamped can generate 128 bit time sortable traceid's compatible
+// with AWS X-Ray and 64 bit spanid's.
+type randomTimestamped struct{}
+
+func (t *randomTimestamped) TraceID() (id model.TraceID) {
+	seededIDLock.Lock()
+	id = model.TraceID{
+		High: uint64(time.Now().Unix()<<32) + uint64(seededIDGen.Int31()),
+		Low:  uint64(seededIDGen.Int63()),
+	}
+	seededIDLock.Unlock()
+	return
+}
+
+func (t *randomTimestamped) SpanID(traceID model.TraceID) (id model.ID) {
+	if !traceID.Empty() {
+		return model.ID(traceID.Low)
+	}
+	seededIDLock.Lock()
+	id = model.ID(seededIDGen.Int63())
+	seededIDLock.Unlock()
+	return
+}

vendor/github.com/openzipkin/zipkin-go/model/annotation.go

+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+// ErrValidTimestampRequired error
+var ErrValidTimestampRequired = errors.New("valid annotation timestamp required")
+
+// Annotation associates an event that explains latency with a timestamp.
+type Annotation struct {
+	Timestamp time.Time
+	Value     string
+}
+
+// MarshalJSON implements custom JSON encoding
+func (a *Annotation) MarshalJSON() ([]byte, error) {
+	return json.Marshal(&struct {
+		Timestamp int64  `json:"timestamp"`
+		Value     string `json:"value"`
+	}{
+		Timestamp: a.Timestamp.Round(time.Microsecond).UnixNano() / 1e3,
+		Value:     a.Value,
+	})
+}
+
+// UnmarshalJSON implements custom JSON decoding
+func (a *Annotation) UnmarshalJSON(b []byte) error {
+	type Alias Annotation
+	annotation := &struct {
+		TimeStamp uint64 `json:"timestamp"`
+		*Alias
+	}{
+		Alias: (*Alias)(a),
+	}
+	if err := json.Unmarshal(b, &annotation); err != nil {
+		return err
+	}
+	if annotation.TimeStamp < 1 {
+		return ErrValidTimestampRequired
+	}
+	a.Timestamp = time.Unix(0, int64(annotation.TimeStamp)*1e3)
+	return nil
+}

vendor/github.com/openzipkin/zipkin-go/model/doc.go

+/*
+Package model contains the Zipkin V2 model which is used by the Zipkin Go
+tracer implementation.
+
+Third party instrumentation libraries can use the model and transport packages
+found in this Zipkin Go library to directly interface with the Zipkin Server or
+Zipkin Collectors without the need to use the tracer implementation itself.
+*/
+package model

vendor/github.com/openzipkin/zipkin-go/model/endpoint.go

+package model
+
+import "net"
+
+// Endpoint holds the network context of a node in the service graph.
+type Endpoint struct {
+	ServiceName string `json:"serviceName,omitempty"`
+	IPv4        net.IP `json:"ipv4,omitempty"`
+	IPv6        net.IP `json:"ipv6,omitempty"`
+	Port        uint16 `json:"port,omitempty"`
+}
+
+// Empty returns if all Endpoint properties are empty / unspecified.
+func (e *Endpoint) Empty() bool {
+	return e == nil ||
+		(e.ServiceName == "" && e.Port == 0 && len(e.IPv4) == 0 && len(e.IPv6) == 0)
+}

vendor/github.com/openzipkin/zipkin-go/model/kind.go

+package model
+
+// Kind clarifies context of timestamp, duration and remoteEndpoint in a span.
+type Kind string
+
+// Available Kind values
+const (
+	Undetermined Kind = ""
+	Client       Kind = "CLIENT"
+	Server       Kind = "SERVER"
+	Producer     Kind = "PRODUCER"
+	Consumer     Kind = "CONSUMER"
+)

vendor/github.com/openzipkin/zipkin-go/model/span.go

+package model
+
+import (
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+// unmarshal errors
+var (
+	ErrValidTraceIDRequired  = errors.New("valid traceId required")
+	ErrValidIDRequired       = errors.New("valid span id required")
+	ErrValidDurationRequired = errors.New("valid duration required")
+)
+
+// SpanContext holds the context of a Span.
+type SpanContext struct {
+	TraceID  TraceID `json:"traceId"`
+	ID       ID      `json:"id"`
+	ParentID *ID     `json:"parentId,omitempty"`
+	Debug    bool    `json:"debug,omitempty"`
+	Sampled  *bool   `json:"-"`
+	Err      error   `json:"-"`
+}
+
+// SpanModel structure.
+//
+// If using this library to instrument your application you will not need to
+// directly access or modify this representation. The SpanModel is exported for
+// use cases involving 3rd party Go instrumentation libraries desiring to
+// export data to a Zipkin server using the Zipkin V2 Span model.
+type SpanModel struct {
+	SpanContext
+	Name           string            `json:"name,omitempty"`
+	Kind           Kind              `json:"kind,omitempty"`
+	Timestamp      time.Time         `json:"-"`
+	Duration       time.Duration     `json:"-"`
+	Shared         bool              `json:"shared,omitempty"`
+	LocalEndpoint  *Endpoint         `json:"localEndpoint,omitempty"`
+	RemoteEndpoint *Endpoint         `json:"remoteEndpoint,omitempty"`
+	Annotations    []Annotation      `json:"annotations,omitempty"`
+	Tags           map[string]string `json:"tags,omitempty"`
+}
+
+// MarshalJSON exports our Model into the correct format for the Zipkin V2 API.
+func (s SpanModel) MarshalJSON() ([]byte, error) {
+	type Alias SpanModel
+
+	var timestamp int64
+	if !s.Timestamp.IsZero() {
+		if s.Timestamp.Unix() < 1 {
+			// Zipkin does not allow Timestamps before Unix epoch
+			return nil, ErrValidTimestampRequired
+		}
+		timestamp = s.Timestamp.Round(time.Microsecond).UnixNano() / 1e3
+	}
+
+	if s.Duration < time.Microsecond {
+		if s.Duration < 0 {
+			// negative duration is not allowed and signals a timing logic error
+			return nil, ErrValidDurationRequired
+		} else if s.Duration > 0 {
+			// sub microsecond durations are reported as 1 microsecond
+			s.Duration = 1 * time.Microsecond
+		}
+	} else {
+		// Duration will be rounded to nearest microsecond representation.
+		//
+		// NOTE: Duration.Round() is not available in Go 1.8 which we still support.
+		// To handle microsecond resolution rounding we'll add 500 nanoseconds to
+		// the duration. When truncated to microseconds in the call to marshal, it
+		// will be naturally rounded. See TestSpanDurationRounding in span_test.go
+		s.Duration += 500 * time.Nanosecond
+	}
+
+	if s.LocalEndpoint.Empty() {
+		s.LocalEndpoint = nil
+	}
+
+	if s.RemoteEndpoint.Empty() {
+		s.RemoteEndpoint = nil
+	}
+
+	return json.Marshal(&struct {
+		T int64 `json:"timestamp,omitempty"`
+		D int64 `json:"duration,omitempty"`
+		Alias
+	}{
+		T:     timestamp,
+		D:     s.Duration.Nanoseconds() / 1e3,
+		Alias: (Alias)(s),
+	})
+}
+
+// UnmarshalJSON imports our Model from a Zipkin V2 API compatible span
+// representation.
+func (s *SpanModel) UnmarshalJSON(b []byte) error {
+	type Alias SpanModel
+	span := &struct {
+		T uint64 `json:"timestamp,omitempty"`
+		D uint64 `json:"duration,omitempty"`
+		*Alias
+	}{
+		Alias: (*Alias)(s),
+	}
+	if err := json.Unmarshal(b, &span); err != nil {
+		return err
+	}
+	if s.ID < 1 {
+		return ErrValidIDRequired
+	}
+	if span.T > 0 {
+		s.Timestamp = time.Unix(0, int64(span.T)*1e3)
+	}
+	s.Duration = time.Duration(span.D*1e3) * time.Nanosecond
+	if s.LocalEndpoint.Empty() {
+		s.LocalEndpoint = nil
+	}
+
+	if s.RemoteEndpoint.Empty() {
+		s.RemoteEndpoint = nil
+	}
+	return nil
+}

vendor/github.com/openzipkin/zipkin-go/model/span_id.go

+package model
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// ID type
+type ID uint64
+
+// String outputs the 64-bit ID as hex string.
+func (i ID) String() string {
+	return fmt.Sprintf("%016x", uint64(i))
+}
+
+// MarshalJSON serializes an ID type (SpanID, ParentSpanID) to HEX.
+func (i ID) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%q", i.String())), nil
+}
+
+// UnmarshalJSON deserializes an ID type (SpanID, ParentSpanID) from HEX.
+func (i *ID) UnmarshalJSON(b []byte) (err error) {
+	var id uint64
+	if len(b) < 3 {
+		return nil
+	}
+	id, err = strconv.ParseUint(string(b[1:len(b)-1]), 16, 64)
+	*i = ID(id)
+	return err
+}

vendor/github.com/openzipkin/zipkin-go/model/traceid.go

+package model
+
+import (
+	"fmt"
+	"strconv"
+)
+
+// TraceID is a 128 bit number internally stored as 2x uint64 (high & low).
+// In case of 64 bit traceIDs, the value can be found in Low.
+type TraceID struct {
+	High uint64
+	Low  uint64
+}
+
+// Empty returns if TraceID has zero value.
+func (t TraceID) Empty() bool {
+	return t.Low == 0 && t.High == 0
+}
+
+// String outputs the 128-bit traceID as hex string.
+func (t TraceID) String() string {
+	if t.High == 0 {
+		return fmt.Sprintf("%016x", t.Low)
+	}
+	return fmt.Sprintf("%016x%016x", t.High, t.Low)
+}
+
+// TraceIDFromHex returns the TraceID from a hex string.
+func TraceIDFromHex(h string) (t TraceID, err error) {
+	if len(h) > 16 {
+		if t.High, err = strconv.ParseUint(h[0:len(h)-16], 16, 64); err != nil {
+			return
+		}
+		t.Low, err = strconv.ParseUint(h[len(h)-16:], 16, 64)
+		return
+	}
+	t.Low, err = strconv.ParseUint(h, 16, 64)
+	return
+}
+
+// MarshalJSON custom JSON serializer to export the TraceID in the required
+// zero padded hex representation.
+func (t TraceID) MarshalJSON() ([]byte, error) {
+	return []byte(fmt.Sprintf("%q", t.String())), nil
+}
+
+// UnmarshalJSON custom JSON deserializer to retrieve the traceID from the hex
+// encoded representation.
+func (t *TraceID) UnmarshalJSON(traceID []byte) error {
+	if len(traceID) < 3 {
+		return ErrValidTraceIDRequired
+	}
+	// A valid JSON string is encoded wrapped in double quotes. We need to trim
+	// these before converting the hex payload.
+	tID, err := TraceIDFromHex(string(traceID[1 : len(traceID)-1]))
+	if err != nil {
+		return err
+	}
+	*t = tID
+	return nil
+}

vendor/github.com/openzipkin/zipkin-go/noop.go

+package zipkin
+
+import (
+	"time"
+
+	"github.com/openzipkin/zipkin-go/model"
+)
+
+type noopSpan struct {
+	model.SpanContext
+}
+
+func (n *noopSpan) Context() model.SpanContext { return n.SpanContext }
+
+func (n *noopSpan) SetName(string) {}
+
+func (*noopSpan) SetRemoteEndpoint(*model.Endpoint) {}
+
+func (*noopSpan) Annotate(time.Time, string) {}
+
+func (*noopSpan) Tag(string, string) {}
+
+func (*noopSpan) Finish() {}
+
+func (*noopSpan) Flush() {}

vendor/github.com/openzipkin/zipkin-go/propagation/propagation.go

+/*
+Package propagation holds the required function signatures for Injection and
+Extraction as used by the Zipkin Tracer.
+
+Subpackages of this package contain officially supported standard propagation
+implementations.
+*/
+package propagation
+
+import "github.com/openzipkin/zipkin-go/model"
+
+// Extractor function signature
+type Extractor func() (*model.SpanContext, error)
+
+// Injector function signature
+type Injector func(model.SpanContext) error

vendor/github.com/openzipkin/zipkin-go/reporter/http/http.go

+/*
+Package http implements a HTTP reporter to send spans to Zipkin V2 collectors.
+*/
+package http
+
+import (
+	"bytes"
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+	"sync"
+	"time"
+
+	"github.com/openzipkin/zipkin-go/model"
+	"github.com/openzipkin/zipkin-go/reporter"
+)
+
+// defaults
+const (
+	defaultTimeout       = time.Second * 5 // timeout for http request in seconds
+	defaultBatchInterval = time.Second * 1 // BatchInterval in seconds
+	defaultBatchSize     = 100
+	defaultMaxBacklog    = 1000
+)
+
+// httpReporter will send spans to a Zipkin HTTP Collector using Zipkin V2 API.
+type httpReporter struct {
+	url           string
+	client        *http.Client
+	logger        *log.Logger
+	batchInterval time.Duration
+	batchSize     int
+	maxBacklog    int
+	sendMtx       *sync.Mutex
+	batchMtx      *sync.Mutex
+	batch         []*model.SpanModel
+	spanC         chan *model.SpanModel
+	quit          chan struct{}
+	shutdown      chan error
+	reqCallback   RequestCallbackFn
+}
+
+// Send implements reporter
+func (r *httpReporter) Send(s model.SpanModel) {
+	r.spanC <- &s
+}
+
+// Close implements reporter
+func (r *httpReporter) Close() error {
+	close(r.quit)
+	return <-r.shutdown
+}
+
+func (r *httpReporter) loop() {
+	var (
+		nextSend   = time.Now().Add(r.batchInterval)
+		ticker     = time.NewTicker(r.batchInterval / 10)
+		tickerChan = ticker.C
+	)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case span := <-r.spanC:
+			currentBatchSize := r.append(span)
+			if currentBatchSize >= r.batchSize {
+				nextSend = time.Now().Add(r.batchInterval)
+				go func() {
+					_ = r.sendBatch()
+				}()
+			}
+		case <-tickerChan:
+			if time.Now().After(nextSend) {
+				nextSend = time.Now().Add(r.batchInterval)
+				go func() {
+					_ = r.sendBatch()
+				}()
+			}
+		case <-r.quit:
+			r.shutdown <- r.sendBatch()
+			return
+		}
+	}
+}
+
+func (r *httpReporter) append(span *model.SpanModel) (newBatchSize int) {
+	r.batchMtx.Lock()
+
+	r.batch = append(r.batch, span)
+	if len(r.batch) > r.maxBacklog {
+		dispose := len(r.batch) - r.maxBacklog
+		r.logger.Printf("backlog too long, disposing %d spans", dispose)
+		r.batch = r.batch[dispose:]
+	}
+	newBatchSize = len(r.batch)
+
+	r.batchMtx.Unlock()
+	return
+}
+
+func (r *httpReporter) sendBatch() error {
+	// in order to prevent sending the same batch twice
+	r.sendMtx.Lock()
+	defer r.sendMtx.Unlock()
+
+	// Select all current spans in the batch to be sent
+	r.batchMtx.Lock()
+	sendBatch := r.batch[:]
+	r.batchMtx.Unlock()
+
+	if len(sendBatch) == 0 {
+		return nil
+	}
+
+	body, err := json.Marshal(sendBatch)
+	if err != nil {
+		r.logger.Printf("failed when marshalling the spans batch: %s\n", err.Error())
+		return err
+	}
+
+	req, err := http.NewRequest("POST", r.url, bytes.NewReader(body))
+	if err != nil {
+		r.logger.Printf("failed when creating the request: %s\n", err.Error())
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if r.reqCallback != nil {
+		r.reqCallback(req)
+	}
+
+	resp, err := r.client.Do(req)
+	if err != nil {
+		r.logger.Printf("failed to send the request: %s\n", err.Error())
+		return err
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode < 200 || resp.StatusCode > 299 {
+		r.logger.Printf("failed the request with status code %d\n", resp.StatusCode)
+	}
+
+	// Remove sent spans from the batch even if they were not saved
+	r.batchMtx.Lock()
+	r.batch = r.batch[len(sendBatch):]
+	r.batchMtx.Unlock()
+
+	return nil
+}
+
+// RequestCallbackFn receives the initialized request from the Collector before
+// sending it over the wire. This allows one to plug in additional headers or
+// do other customization.
+type RequestCallbackFn func(*http.Request)
+
+// ReporterOption sets a parameter for the HTTP Reporter
+type ReporterOption func(r *httpReporter)
+
+// Timeout sets maximum timeout for http request.
+func Timeout(duration time.Duration) ReporterOption {
+	return func(r *httpReporter) { r.client.Timeout = duration }
+}
+
+// BatchSize sets the maximum batch size, after which a collect will be
+// triggered. The default batch size is 100 traces.
+func BatchSize(n int) ReporterOption {
+	return func(r *httpReporter) { r.batchSize = n }
+}
+
+// MaxBacklog sets the maximum backlog size. When batch size reaches this
+// threshold, spans from the beginning of the batch will be disposed.
+func MaxBacklog(n int) ReporterOption {
+	return func(r *httpReporter) { r.maxBacklog = n }
+}
+
+// BatchInterval sets the maximum duration we will buffer traces before
+// emitting them to the collector. The default batch interval is 1 second.
+func BatchInterval(d time.Duration) ReporterOption {
+	return func(r *httpReporter) { r.batchInterval = d }
+}
+
+// Client sets a custom http client to use.
+func Client(client *http.Client) ReporterOption {
+	return func(r *httpReporter) { r.client = client }
+}
+
+// RequestCallback registers a callback function to adjust the reporter
+// *http.Request before it sends the request to Zipkin.
+func RequestCallback(rc RequestCallbackFn) ReporterOption {
+	return func(r *httpReporter) { r.reqCallback = rc }
+}
+
+// NewReporter returns a new HTTP Reporter.
+// url should be the endpoint to send the spans to, e.g.
+// http://localhost:9411/api/v2/spans
+func NewReporter(url string, opts ...ReporterOption) reporter.Reporter {
+	r := httpReporter{
+		url:           url,
+		logger:        log.New(os.Stderr, "", log.LstdFlags),
+		client:        &http.Client{Timeout: defaultTimeout},
+		batchInterval: defaultBatchInterval,
+		batchSize:     defaultBatchSize,
+		maxBacklog:    defaultMaxBacklog,
+		batch:         []*model.SpanModel{},
+		spanC:         make(chan *model.SpanModel),
+		quit:          make(chan struct{}, 1),
+		shutdown:      make(chan error, 1),
+		sendMtx:       &sync.Mutex{},
+		batchMtx:      &sync.Mutex{},
+	}
+
+	for _, opt := range opts {
+		opt(&r)
+	}
+
+	go r.loop()
+
+	return &r
+}