| commit | 983446b8dae3871316dc8610f7aa61e160b50b31 | [log] [tgz] |
|---|---|---|
| author | JBD <jbd@golang.org> | Sun Mar 18 07:58:56 2018 -0700 |
| committer | GitHub <noreply@github.com> | Sun Mar 18 07:58:56 2018 -0700 |
| tree | 6d797e345e165fe573546cfd6f25f637dade4afc | |
| parent | 92b618f4c8750700550de8b24e48030ff7cba293 [diff] |
Don't record measurements with no subscription (#600) Suggested by Ramon, immediately dropping the measurements from the measures with no subscription rather than doing it at a later time significantly improves the performance on the critical path. Before: BenchmarkRecord0-8 500000000 3.09 ns/op BenchmarkRecord1-8 5000000 366 ns/op BenchmarkRecord8-8 3000000 412 ns/op BenchmarkRecord8_Parallel-8 2000000 804 ns/op BenchmarkRecord8_8Tags-8 3000000 415 ns/op After: BenchmarkRecord0-8 1000000000 2.58 ns/op BenchmarkRecord1-8 30000000 36.9 ns/op BenchmarkRecord8-8 20000000 89.4 ns/op BenchmarkRecord8_Parallel-8 30000000 44.8 ns/op BenchmarkRecord8_8Tags-8 20000000 90.1 ns/op
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.
This project is still at a very early stage of development. The API is changing rapidly, vendoring is recommended.
$ go get -u go.opencensus.io
OpenCensus Go libraries require Go 1.8 or later.
OpenCensus can export instrumentation data to various backends. Currently, OpenCensus supports:
In a microservices environment, a user request may go through 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.
Tags represent propagated key-value pairs. They are propagated using context.Context in the same process or can be encoded to be transmitted on the wire and decoded back to a tag.Map at the destination.
Package tag provides a builder to create tag maps and put it into the current context. To propagate a tag map to downstream methods and RPCs, New will add the produced tag map to the current context. If there is already a tag map in the current context, it will be replaced.
ctx, err = tag.New(ctx,
tag.Insert(osKey, "macOS-10.12.5"),
tag.Upsert(userIDKey, "cde36753ed"),
)
if err != nil {
log.Fatal(err)
}
OpenCensus is a low-overhead framework even if instrumentation is always enabled. In order to be so, it is optimized to make recording of data points fast and separate from the data aggregation.
OpenCensus stats collection happens in two stages:
Measurements are data points associated with a measure. Recording implicitly tags the set of Measurements with the tags from the provided context:
stats.Record(ctx, videoSize.M(102478))
Views are how Measures are aggregated. You can think of them as queries over the set of recorded data points (measurements).
Views have two parts: the tags to group by and the aggregation type used.
Currently four types of aggregations are supported:
distAgg := view.DistributionAggregation{0, 1 << 32, 2 << 32, 3 << 32}
countAgg := view.CountAggregation{}
sumAgg := view.SumAggregation{}
meanAgg := view.MeanAggregation{}
Here we create a view with the DistributionAggregation over our measure.
if err = view.Subscribe(&view.View{
Name: "my.org/video_size_distribution",
Description: "distribution of processed video size over time",
Measure: videoSize,
Aggregation: view.DistributionAggregation([]float64{0, 1 << 32, 2 << 32, 3 << 32}),
}); err != nil {
log.Fatalf("Failed to subscribe to view: %v", err)
}
Subscribe begins collecting data for the view. Subscribed views' data will be exported via the registered exporters.
ctx, span := trace.StartSpan(ctx, "your choice of name")
defer span.End()
OpenCensus tags can be applied as profiler labels for users who are on Go 1.9 and above.
ctx, err = tag.New(ctx, tag.Insert(osKey, "macOS-10.12.5"), tag.Insert(userIDKey, "fff0989878"), ) if err != nil { log.Fatal(err) } tag.Do(ctx, func(ctx context.Context) { // Do work. // When profiling is on, samples will be // recorded with the key/values from the tag map. })
A screenshot of the CPU profile from the program above:
