@@ -117,7 +117,8 @@ github.com/bsphere/le_go                            7a984a84b5492ae539b79b62fb4a

 # gcplogs deps

 golang.org/x/oauth2                                 bf48bf16ab8d622ce64ec6ce98d2c98f916b6303

 google.golang.org/api                               de943baf05a022a8f921b544b7827bacaba1aed5

-go.opencensus.io                                    c3ed530f775d85e577ca652cb052a52c078aad26 # v0.11.0

+github.com/golang/groupcache                        869f871628b6baa9cfbc11732cdf6546b17c1298

+go.opencensus.io                                    d835ff86be02193d324330acdb7d65546b05f814 # v0.22.3

 cloud.google.com/go                                 ceeb313ad77b789a7fa5287b36a1d127b69b7093 # v0.44.3

 github.com/googleapis/gax-go                        bd5b16380fd03dc758d11cef74ba2e3bc8b0e8c2 # v2.0.5

 google.golang.org/genproto                          3f1135a288c9a07e340ae8ba4cc6c7065a3160e8

new file mode 100644

@@ -0,0 +1,191 @@

+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:

+

+You must give any other recipients of the Work or Derivative Works a copy of

+this License; and

+You must cause any modified files to carry prominent notices stating that You

+changed the files; and

+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

+If the Work includes a "NOTICE" text file as part of its distribution, then any

+Derivative Works that You distribute must include a readable copy of the

+attribution notices contained within such NOTICE file, excluding those notices

+that do not pertain to any part of the Derivative Works, in at least one of the

+following places: within a NOTICE text file distributed as part of the

+Derivative Works; within the Source form or documentation, if provided along

+with the Derivative Works; or, within a display generated by the Derivative

+Works, if and wherever such third-party notices normally appear. The contents of

+the NOTICE file are for informational purposes only and do not modify the

+License. You may add Your own attribution notices within Derivative Works that

+You distribute, alongside or as an addendum to the NOTICE text from the Work,

+provided that such additional attribution notices cannot be construed as

+modifying the License.

+You may add Your own copyright statement to Your modifications and may provide

+additional or different license terms and conditions for use, reproduction, or

+distribution of Your modifications, or for any such Derivative Works as a whole,

+provided Your use, reproduction, and distribution of the Work otherwise complies

+with the conditions stated in this License.

+

+5. Submission of Contributions.

+

+Unless You explicitly state otherwise, any Contribution intentionally submitted

+for inclusion in the Work by You to the Licensor shall be under the terms and

+conditions of this License, without any additional terms or conditions.

+Notwithstanding the above, nothing herein shall supersede or modify the terms of

+any separate license agreement you may have executed with Licensor regarding

+such Contributions.

+

+6. Trademarks.

+

+This License does not grant permission to use the trade names, trademarks,

+service marks, or product names of the Licensor, except as required for

+reasonable and customary use in describing the origin of the Work and

+reproducing the content of the NOTICE file.

+

+7. Disclaimer of Warranty.

+

+Unless required by applicable law or agreed to in writing, Licensor provides the

+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,

+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,

+including, without limitation, any warranties or conditions of TITLE,

+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are

+solely responsible for determining the appropriateness of using or

+redistributing the Work and assume any risks associated with Your exercise of

+permissions under this License.

+

+8. Limitation of Liability.

+

+In no event and under no legal theory, whether in tort (including negligence),

+contract, or otherwise, unless required by applicable law (such as deliberate

+and grossly negligent acts) or agreed to in writing, shall any Contributor be

+liable to You for damages, including any direct, indirect, special, incidental,

+or consequential damages of any character arising as a result of this License or

+out of the use or inability to use the Work (including but not limited to

+damages for loss of goodwill, work stoppage, computer failure or malfunction, or

+any and all other commercial damages or losses), even if such Contributor has

+been advised of the possibility of such damages.

+

+9. Accepting Warranty or Additional Liability.

+

+While redistributing the Work or Derivative Works thereof, You may choose to

+offer, and charge a fee for, acceptance of support, warranty, indemnity, or

+other liability obligations and/or rights consistent with this License. However,

+in accepting such obligations, You may act only on Your own behalf and on Your

+sole responsibility, not on behalf of any other Contributor, and only if You

+agree to indemnify, defend, and hold each Contributor harmless for any liability

+incurred by, or claims asserted against, such Contributor by reason of your

+accepting any such warranty or additional liability.

+

+END OF TERMS AND CONDITIONS

+

+APPENDIX: How to apply the Apache License to your work

+

+To apply the Apache License to your work, attach the following boilerplate

+notice, with the fields enclosed by brackets "[]" replaced with your own

+identifying information. (Don't include the brackets!) The text should be

+enclosed in the appropriate comment syntax for the file format. We also

+recommend that a file or class name and description of purpose be included on

+the same "printed page" as the copyright notice for easier identification within

+third-party archives.

+

+   Copyright [yyyy] [name of copyright owner]

+

+   Licensed under the Apache License, Version 2.0 (the "License");

+   you may not use this file except in compliance with the License.

+   You may obtain a copy of the License at

+

+     http://www.apache.org/licenses/LICENSE-2.0

+

+   Unless required by applicable law or agreed to in writing, software

+   distributed under the License is distributed on an "AS IS" BASIS,

+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+   See the License for the specific language governing permissions and

+   limitations under the License.

new file mode 100644

@@ -0,0 +1,73 @@

+# groupcache

+

+## Summary

+

+groupcache is a caching and cache-filling library, intended as a

+replacement for memcached in many cases.

+

+For API docs and examples, see http://godoc.org/github.com/golang/groupcache

+

+## Comparison to memcached

+

+### **Like memcached**, groupcache:

+

+ * shards by key to select which peer is responsible for that key

+

+### **Unlike memcached**, groupcache:

+

+ * does not require running a separate set of servers, thus massively

+   reducing deployment/configuration pain.  groupcache is a client

+   library as well as a server.  It connects to its own peers.

+

+ * comes with a cache filling mechanism.  Whereas memcached just says

+   "Sorry, cache miss", often resulting in a thundering herd of

+   database (or whatever) loads from an unbounded number of clients

+   (which has resulted in several fun outages), groupcache coordinates

+   cache fills such that only one load in one process of an entire

+   replicated set of processes populates the cache, then multiplexes

+   the loaded value to all callers.

+

+ * does not support versioned values.  If key "foo" is value "bar",

+   key "foo" must always be "bar".  There are neither cache expiration

+   times, nor explicit cache evictions.  Thus there is also no CAS,

+   nor Increment/Decrement.  This also means that groupcache....

+

+ * ... supports automatic mirroring of super-hot items to multiple

+   processes.  This prevents memcached hot spotting where a machine's

+   CPU and/or NIC are overloaded by very popular keys/values.

+

+ * is currently only available for Go.  It's very unlikely that I

+   (bradfitz@) will port the code to any other language.

+

+## Loading process

+

+In a nutshell, a groupcache lookup of **Get("foo")** looks like:

+

+(On machine #5 of a set of N machines running the same code)

+

+ 1. Is the value of "foo" in local memory because it's super hot?  If so, use it.

+

+ 2. Is the value of "foo" in local memory because peer #5 (the current

+    peer) is the owner of it?  If so, use it.

+

+ 3. Amongst all the peers in my set of N, am I the owner of the key

+    "foo"?  (e.g. does it consistent hash to 5?)  If so, load it.  If

+    other callers come in, via the same process or via RPC requests

+    from peers, they block waiting for the load to finish and get the

+    same answer.  If not, RPC to the peer that's the owner and get

+    the answer.  If the RPC fails, just load it locally (still with

+    local dup suppression).

+

+## Users

+

+groupcache is in production use by dl.google.com (its original user),

+parts of Blogger, parts of Google Code, parts of Google Fiber, parts

+of Google production monitoring systems, etc.

+

+## Presentations

+

+See http://talks.golang.org/2013/oscon-dl.slide

+

+## Help

+

+Use the golang-nuts mailing list for any discussion or questions.

new file mode 100644

@@ -0,0 +1,133 @@

+/*

+Copyright 2013 Google 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 lru implements an LRU cache.

+package lru

+

+import "container/list"

+

+// Cache is an LRU cache. It is not safe for concurrent access.

+type Cache struct {

+	// MaxEntries is the maximum number of cache entries before

+	// an item is evicted. Zero means no limit.

+	MaxEntries int

+

+	// OnEvicted optionally specifies a callback function to be

+	// executed when an entry is purged from the cache.

+	OnEvicted func(key Key, value interface{})

+

+	ll    *list.List

+	cache map[interface{}]*list.Element

+}

+

+// A Key may be any value that is comparable. See http://golang.org/ref/spec#Comparison_operators

+type Key interface{}

+

+type entry struct {

+	key   Key

+	value interface{}

+}

+

+// New creates a new Cache.

+// If maxEntries is zero, the cache has no limit and it's assumed

+// that eviction is done by the caller.

+func New(maxEntries int) *Cache {

+	return &Cache{

+		MaxEntries: maxEntries,

+		ll:         list.New(),

+		cache:      make(map[interface{}]*list.Element),

+	}

+}

+

+// Add adds a value to the cache.

+func (c *Cache) Add(key Key, value interface{}) {

+	if c.cache == nil {

+		c.cache = make(map[interface{}]*list.Element)

+		c.ll = list.New()

+	}

+	if ee, ok := c.cache[key]; ok {

+		c.ll.MoveToFront(ee)

+		ee.Value.(*entry).value = value

+		return

+	}

+	ele := c.ll.PushFront(&entry{key, value})

+	c.cache[key] = ele

+	if c.MaxEntries != 0 && c.ll.Len() > c.MaxEntries {

+		c.RemoveOldest()

+	}

+}

+

+// Get looks up a key's value from the cache.

+func (c *Cache) Get(key Key) (value interface{}, ok bool) {

+	if c.cache == nil {

+		return

+	}

+	if ele, hit := c.cache[key]; hit {

+		c.ll.MoveToFront(ele)

+		return ele.Value.(*entry).value, true

+	}

+	return

+}

+

+// Remove removes the provided key from the cache.

+func (c *Cache) Remove(key Key) {

+	if c.cache == nil {

+		return

+	}

+	if ele, hit := c.cache[key]; hit {

+		c.removeElement(ele)

+	}

+}

+

+// RemoveOldest removes the oldest item from the cache.

+func (c *Cache) RemoveOldest() {

+	if c.cache == nil {

+		return

+	}

+	ele := c.ll.Back()

+	if ele != nil {

+		c.removeElement(ele)

+	}

+}

+

+func (c *Cache) removeElement(e *list.Element) {

+	c.ll.Remove(e)

+	kv := e.Value.(*entry)

+	delete(c.cache, kv.key)

+	if c.OnEvicted != nil {

+		c.OnEvicted(kv.key, kv.value)

+	}

+}

+

+// Len returns the number of items in the cache.

+func (c *Cache) Len() int {

+	if c.cache == nil {

+		return 0

+	}

+	return c.ll.Len()

+}

+

+// Clear purges all stored items from the cache.

+func (c *Cache) Clear() {

+	if c.OnEvicted != nil {

+		for _, e := range c.cache {

+			kv := e.Value.(*entry)

+			c.OnEvicted(kv.key, kv.value)

+		}

+	}

+	c.ll = nil

+	c.cache = nil

+}

@@ -7,7 +7,9 @@

 OpenCensus Go is a Go implementation of OpenCensus, a toolkit for

 collecting application performance and behavior monitoring data.

-Currently it consists of three major components: tags, stats, and tracing.

+Currently it consists of three major components: tags, stats and tracing.

+

+#### OpenCensus and OpenTracing have merged to form OpenTelemetry, which serves as the next major version of OpenCensus and OpenTracing. OpenTelemetry will offer backwards compatibility with existing OpenCensus integrations, and we will continue to make security patches to existing OpenCensus libraries for two years. Read more about the merger [here](https://medium.com/opentracing/a-roadmap-to-convergence-b074e5815289).

 ## Installation

@@ -22,17 +24,42 @@ The use of vendoring or a dependency management tool is recommended.

 OpenCensus Go libraries require Go 1.8 or later.

+## Getting Started

+

+The easiest way to get started using OpenCensus in your application is to use an existing

+integration with your RPC framework:

+

+* [net/http](https://godoc.org/go.opencensus.io/plugin/ochttp)

+* [gRPC](https://godoc.org/go.opencensus.io/plugin/ocgrpc)

+* [database/sql](https://godoc.org/github.com/opencensus-integrations/ocsql)

+* [Go kit](https://godoc.org/github.com/go-kit/kit/tracing/opencensus)

+* [Groupcache](https://godoc.org/github.com/orijtech/groupcache)

+* [Caddy webserver](https://godoc.org/github.com/orijtech/caddy)

+* [MongoDB](https://godoc.org/github.com/orijtech/mongo-go-driver)

+* [Redis gomodule/redigo](https://godoc.org/github.com/orijtech/redigo)

+* [Redis goredis/redis](https://godoc.org/github.com/orijtech/redis)

+* [Memcache](https://godoc.org/github.com/orijtech/gomemcache)

+

+If you're using a framework not listed here, you could either implement your own middleware for your

+framework or use [custom stats](#stats) and [spans](#spans) directly in your application.

+

 ## Exporters

-OpenCensus can export instrumentation data to various backends. 

-Currently, OpenCensus supports:

+OpenCensus can export instrumentation data to various backends.

+OpenCensus has exporter implementations for the following, users

+can implement their own exporters by implementing the exporter interfaces

+([stats](https://godoc.org/go.opencensus.io/stats/view#Exporter),

+[trace](https://godoc.org/go.opencensus.io/trace#Exporter)):

 * [Prometheus][exporter-prom] for stats

 * [OpenZipkin][exporter-zipkin] for traces

-* Stackdriver [Monitoring][exporter-stackdriver] and [Trace][exporter-stackdriver]

+* [Stackdriver][exporter-stackdriver] Monitoring for stats and Trace for traces

 * [Jaeger][exporter-jaeger] for traces

 * [AWS X-Ray][exporter-xray] for traces

-

+* [Datadog][exporter-datadog] for stats and traces

+* [Graphite][exporter-graphite] for stats

+* [Honeycomb][exporter-honeycomb] for traces

+* [New Relic][exporter-newrelic] for stats and traces

 ## Overview

@@ -43,13 +70,6 @@ multiple services until there is a response. OpenCensus allows

 you to instrument your services and collect diagnostics data all

 through your services end-to-end.

-Start with instrumenting HTTP and gRPC clients and servers,

-then add additional custom instrumentation if needed.

-

-* [HTTP guide](https://github.com/census-instrumentation/opencensus-go/tree/master/examples/http)

-* [gRPC guide](https://github.com/census-instrumentation/opencensus-go/tree/master/examples/grpc)

-

-

 ## Tags

 Tags represent propagated key-value pairs. They are propagated using `context.Context`

@@ -57,11 +77,11 @@ in the same process or can be encoded to be transmitted on the wire. Usually, th

 be handled by an integration plugin, e.g. `ocgrpc.ServerHandler` and `ocgrpc.ClientHandler`

 for gRPC.

-Package tag allows adding or modifying tags in the current context.

+Package `tag` allows adding or modifying tags in the current context.

 [embedmd]:# (internal/readme/tags.go new)

 ```go

-ctx, err = tag.New(ctx,

+ctx, err := tag.New(ctx,

 	tag.Insert(osKey, "macOS-10.12.5"),

 	tag.Upsert(userIDKey, "cde36753ed"),

 )

@@ -106,7 +126,7 @@ Currently three types of aggregations are supported:

 [embedmd]:# (internal/readme/stats.go aggs)

 ```go

-distAgg := view.Distribution(0, 1<<32, 2<<32, 3<<32)

+distAgg := view.Distribution(1<<32, 2<<32, 3<<32)

 countAgg := view.Count()

 sumAgg := view.Sum()

 ```

@@ -116,26 +136,79 @@ Here we create a view with the DistributionAggregation over our measure.

 [embedmd]:# (internal/readme/stats.go view)

 ```go

 if err := view.Register(&view.View{

-	Name:        "my.org/video_size_distribution",

+	Name:        "example.com/video_size_distribution",

 	Description: "distribution of processed video size over time",

 	Measure:     videoSize,

-	Aggregation: view.Distribution(0, 1<<32, 2<<32, 3<<32),

+	Aggregation: view.Distribution(1<<32, 2<<32, 3<<32),

 }); err != nil {

-	log.Fatalf("Failed to subscribe to view: %v", err)

+	log.Fatalf("Failed to register view: %v", err)

 }

 ```

-Subscribe begins collecting data for the view. Subscribed views' data will be

+Register begins collecting data for the view. Registered views' data will be

 exported via the registered exporters.

 ## Traces

+A distributed trace tracks the progression of a single user request as

+it is handled by the services and processes that make up an application.

+Each step is called a span in the trace. Spans include metadata about the step,

+including especially the time spent in the step, called the span’s latency.

+

+Below you see a trace and several spans underneath it.

+

+![Traces and spans](https://i.imgur.com/7hZwRVj.png)

+

+### Spans

+

+Span is the unit step in a trace. Each span has a name, latency, status and

+additional metadata.

+

+Below we are starting a span for a cache read and ending it

+when we are done:

+

 [embedmd]:# (internal/readme/trace.go startend)

 ```go

-ctx, span := trace.StartSpan(ctx, "your choice of name")

+ctx, span := trace.StartSpan(ctx, "cache.Get")

 defer span.End()

+

+// Do work to get from cache.

 ```

+### Propagation

+

+Spans can have parents or can be root spans if they don't have any parents.

+The current span is propagated in-process and across the network to allow associating

+new child spans with the parent.

+

+In the same process, `context.Context` is used to propagate spans.

+`trace.StartSpan` creates a new span as a root if the current context

+doesn't contain a span. Or, it creates a child of the span that is

+already in current context. The returned context can be used to keep

+propagating the newly created span in the current context.

+

+[embedmd]:# (internal/readme/trace.go startend)

+```go

+ctx, span := trace.StartSpan(ctx, "cache.Get")

+defer span.End()

+

+// Do work to get from cache.

+```

+

+Across the network, OpenCensus provides different propagation

+methods for different protocols.

+

+* gRPC integrations use the OpenCensus' [binary propagation format](https://godoc.org/go.opencensus.io/trace/propagation).

+* HTTP integrations use Zipkin's [B3](https://github.com/openzipkin/b3-propagation)

+  by default but can be configured to use a custom propagation method by setting another

+  [propagation.HTTPFormat](https://godoc.org/go.opencensus.io/trace/propagation#HTTPFormat).

+

+## Execution Tracer

+

+With Go 1.11, OpenCensus Go will support integration with the Go execution tracer.

+See [Debugging Latency in Go](https://medium.com/observability/debugging-latency-in-go-1-11-9f97a7910d68)

+for an example of their mutual use.

+

 ## Profiles

 OpenCensus tags can be applied as profiler labels

@@ -167,7 +240,7 @@ Before version 1.0.0, the following deprecation policy will be observed:

 No backwards-incompatible changes will be made except for the removal of symbols that have

 been marked as *Deprecated* for at least one minor release (e.g. 0.9.0 to 0.10.0). A release

-removing the *Deprecated* functionality will be made no sooner than 28 days after the first 

+removing the *Deprecated* functionality will be made no sooner than 28 days after the first

 release in which the functionality was marked *Deprecated*.

 [travis-image]: https://travis-ci.org/census-instrumentation/opencensus-go.svg?branch=master

@@ -183,8 +256,12 @@ release in which the functionality was marked *Deprecated*.

 [new-ex]: https://godoc.org/go.opencensus.io/tag#example-NewMap

 [new-replace-ex]: https://godoc.org/go.opencensus.io/tag#example-NewMap--Replace

-[exporter-prom]: https://godoc.org/go.opencensus.io/exporter/prometheus

+[exporter-prom]: https://godoc.org/contrib.go.opencensus.io/exporter/prometheus

 [exporter-stackdriver]: https://godoc.org/contrib.go.opencensus.io/exporter/stackdriver

-[exporter-zipkin]: https://godoc.org/go.opencensus.io/exporter/zipkin

-[exporter-jaeger]: https://godoc.org/go.opencensus.io/exporter/jaeger

-[exporter-xray]: https://github.com/census-instrumentation/opencensus-go-exporter-aws

+[exporter-zipkin]: https://godoc.org/contrib.go.opencensus.io/exporter/zipkin

+[exporter-jaeger]: https://godoc.org/contrib.go.opencensus.io/exporter/jaeger

+[exporter-xray]: https://github.com/census-ecosystem/opencensus-go-exporter-aws

+[exporter-datadog]: https://github.com/DataDog/opencensus-go-exporter-datadog

+[exporter-graphite]: https://github.com/census-ecosystem/opencensus-go-exporter-graphite

+[exporter-honeycomb]: https://github.com/honeycombio/opencensus-exporter

+[exporter-newrelic]: https://github.com/newrelic/newrelic-opencensus-exporter-go

new file mode 100644

@@ -0,0 +1,15 @@

+module go.opencensus.io

+

+require (

+	github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6

+	github.com/golang/protobuf v1.3.1

+	github.com/google/go-cmp v0.3.0

+	github.com/stretchr/testify v1.4.0

+	golang.org/x/net v0.0.0-20190620200207-3b0461eec859

+	golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd // indirect

+	golang.org/x/text v0.3.2 // indirect

+	google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb // indirect

+	google.golang.org/grpc v1.20.1

+)

+

+go 1.13

@@ -14,11 +14,16 @@

 package internal // import "go.opencensus.io/internal"

-import "time"

+import (

+	"fmt"

+	"time"

+

+	opencensus "go.opencensus.io"

+)

 // UserAgent is the user agent to be added to the outgoing

 // requests from the exporters.

-const UserAgent = "opencensus-go [0.11.0]"

+var UserAgent = fmt.Sprintf("opencensus-go/%s", opencensus.Version())

 // MonotonicEndTime returns the end time at present

 // but offset from start, monotonically.

@@ -28,5 +33,5 @@ const UserAgent = "opencensus-go [0.11.0]"

 // end as a monotonic time.

 // See https://golang.org/pkg/time/#hdr-Monotonic_Clocks

 func MonotonicEndTime(start time.Time) time.Time {

-	return start.Add(time.Now().Sub(start))

+	return start.Add(time.Since(start))

 }

@@ -17,6 +17,7 @@

 // used interally by the stats collector.

 package tagencoding // import "go.opencensus.io/internal/tagencoding"

+// Values represent the encoded buffer for the values.

 type Values struct {

 	Buffer     []byte

 	WriteIndex int

@@ -31,6 +32,7 @@ func (vb *Values) growIfRequired(expected int) {

 	}

 }

+// WriteValue is the helper method to encode Values from map[Key][]byte.

 func (vb *Values) WriteValue(v []byte) {

 	length := len(v) & 0xff

 	vb.growIfRequired(1 + length)

@@ -49,7 +51,7 @@ func (vb *Values) WriteValue(v []byte) {

 	vb.WriteIndex += length

 }

-// ReadValue is the helper method to read the values when decoding valuesBytes to a map[Key][]byte.

+// ReadValue is the helper method to decode Values to a map[Key][]byte.

 func (vb *Values) ReadValue() []byte {

 	// read length of v

 	length := int(vb.Buffer[vb.ReadIndex])

@@ -67,6 +69,7 @@ func (vb *Values) ReadValue() []byte {

 	return v

 }

+// Bytes returns a reference to already written bytes in the Buffer.

 func (vb *Values) Bytes() []byte {

 	return vb.Buffer[:vb.WriteIndex]

 }

@@ -22,6 +22,7 @@ import (

 // TODO(#412): remove this

 var Trace interface{}

+// LocalSpanStoreEnabled true if the local span store is enabled.

 var LocalSpanStoreEnabled bool

 // BucketConfiguration stores the number of samples to store for span buckets

new file mode 100644

@@ -0,0 +1,19 @@

+// Copyright 2018, OpenCensus 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 metricdata contains the metrics data model.

+//

+// This is an EXPERIMENTAL package, and may change in arbitrary ways without

+// notice.

+package metricdata // import "go.opencensus.io/metric/metricdata"

new file mode 100644

@@ -0,0 +1,38 @@

+// Copyright 2018, OpenCensus 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 metricdata

+

+import (

+	"time"

+)

+

+// Exemplars keys.

+const (

+	AttachmentKeySpanContext = "SpanContext"

+)

+

+// Exemplar is an example data point associated with each bucket of a

+// distribution type aggregation.

+//

+// Their purpose is to provide an example of the kind of thing

+// (request, RPC, trace span, etc.) that resulted in that measurement.

+type Exemplar struct {

+	Value       float64     // the value that was recorded

+	Timestamp   time.Time   // the time the value was recorded

+	Attachments Attachments // attachments (if any)

+}

+

+// Attachments is a map of extra values associated with a recorded data point.

+type Attachments map[string]interface{}

new file mode 100644

@@ -0,0 +1,35 @@

+// Copyright 2018, OpenCensus 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 metricdata

+

+// LabelKey represents key of a label. It has optional

+// description attribute.

+type LabelKey struct {

+	Key         string

+	Description string

+}

+

+// LabelValue represents the value of a label.

+// The zero value represents a missing label value, which may be treated

+// differently to an empty string value by some back ends.

+type LabelValue struct {

+	Value   string // string value of the label

+	Present bool   // flag that indicated whether a value is present or not

+}

+

+// NewLabelValue creates a new non-nil LabelValue that represents the given string.

+func NewLabelValue(val string) LabelValue {

+	return LabelValue{Value: val, Present: true}

+}

new file mode 100644

@@ -0,0 +1,46 @@

+// Copyright 2018, OpenCensus 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 metricdata

+

+import (

+	"time"

+

+	"go.opencensus.io/resource"

+)

+

+// Descriptor holds metadata about a metric.

+type Descriptor struct {

+	Name        string     // full name of the metric

+	Description string     // human-readable description

+	Unit        Unit       // units for the measure

+	Type        Type       // type of measure

+	LabelKeys   []LabelKey // label keys

+}

+

+// Metric represents a quantity measured against a resource with different

+// label value combinations.

+type Metric struct {

+	Descriptor Descriptor         // metric descriptor

+	Resource   *resource.Resource // resource against which this was measured

+	TimeSeries []*TimeSeries      // one time series for each combination of label values

+}

+

+// TimeSeries is a sequence of points associated with a combination of label

+// values.