ctx, err = tag.New(ctx,
	tag.Insert(osKey, "macOS-10.12.5"),
	tag.Upsert(userIDKey, "cde36753ed"),
)

stats.Record(ctx, videoSize.M(102478))

ctx, span := trace.StartSpan(ctx, "your function name")
defer span.End()

distAgg := view.Distribution(0, 1<<32, 2<<32, 3<<32)
countAgg := view.Count()
sumAgg := view.Sum()

if err := view.Register(&view.View{
	Name:        "my.org/video_size_distribution",
	Description: "distribution of processed video size over time",
	Measure:     videoSize,
	Aggregation: view.Distribution(0, 1<<32, 2<<32, 3<<32),
}); err != nil {
	log.Fatalf("Failed to subscribe to view: %v", err)
}

import (
  "go.opencensus.io/stats"
  "go.opencensus.io/tag"
  "go.opencensus.io/stats/view"
)

var (
  requestCounter             *stats.Float64Measure
  codeKey                    tag.Key
  DefaultLatencyDistribution = view.DistributionAggregation{0, 1, 2, 3, 4, 5, 6, 8, 10, 13, 16, 20, 25, 30, 40, 50, 65, 80, 100, 130, 160, 200, 250, 300, 400, 500, 650, 800, 1000, 2000, 5000, 10000, 20000, 50000, 100000}
)
	codeKey, _ = tag.NewKey("banias/keys/code")

  requestCounter, _ = stats.Float64("banias/measures/request_count", "Count of HTTP requests processed", stats.UnitNone)
	view.Subscribe(
		&view.View{
			Name:        "request_count",
			Description: "Count of HTTP requests processed",
			TagKeys:     []tag.Key{codeKey},
			Measure:     requestCounter,
			Aggregation: view.CountAggregation{},
		})

    // requestlatency .....

	view.SetReportingPeriod(1 * time.Second)

// Go Code Example
// 说明：defer 用于资源的释放，会在函数返回之前进行调用。
// 如果有多个 defer表达式，调用顺序类似于栈，越后面的 defer 表达式越先被调用。
func (c *Collector) Collect(ctx *fasthttp.RequestCtx) {

  defer func(begin time.Time) {
      responseTime := float64(time.Since(begin).Nanoseconds() / 1000)
      occtx, _ := tag.New(context.Background(), tag.Insert(codeKey, strconv.Itoa(ctx.Response.StatusCode())), )

      stats.Record(occtx, requestCounter.M(1))
      stats.Record(occtx, requestlatency.M(responseTime))

    }(time.Now())

    /*do some stuff */

}

 import (
 	 "go.opencensus.io/exporter/prometheus"
   "go.opencensus.io/exporter/stackdriver"
    openzipkin "github.com/openzipkin/zipkin-go"
  	 "go.opencensus.io/exporter/zipkin"
    xray "github.com/census-instrumentation/opencensus-go-exporter-aws"
  	 "go.opencensus.io/trace"
   "go.opencensus.io/stats/view"
)

// Opention: Export to Prometheus Monitoring.
 Exporter, err := prometheus.NewExporter(prometheus.Options{})
if err != nil {
	logger.Error("Error creating prometheus exporter  ", zap.Error(err))
}
view.RegisterExporter(pExporter)


 // Opention: Export to Stackdriver Monitoring.
sExporter, err := stackdriver.NewExporter(stackdriver.Options{ProjectID: config.ProjectID})
if err != nil {
	logger.Error("Error creating stackdriver exporter  ", zap.Error(err))
}
view.RegisterExporter(sExporter)

 // Opention: Export to Zipkin Monitoring.
localEndpoint, err := openzipkin.NewEndpoint("service-A", "127.0.1.1:8080")
reporter := http.NewReporter("http://127.0.1.110:9411/api/v2/spans")
defer reporter.Close()
exporter := zipkin.NewExporter(reporter, localEndpoint)
trace.RegisterExporter(exporter)

 // Opention: Export to AWS X-Ray
xe, err := xray.NewExporter(xray.WithVersion("latest"))
if err != nil {
	log.Fatalf("Failed to create AWS X-Ray exporter: %v", err)
}
trace.RegisterExporter(xe)

go go_ping(ctx, "192.168.213.128", 2, time.Second*3, false)
go go_ping(ctx, "192.168.213.128", 2, time.Second*3, false)
go go_ping(ctx, "192.168.213.129", 2, time.Second*5, false)
go_ping(ctx, "192.168.213.128", 2, time.Second*3, false)
go_ping(ctx, "192.168.213.128", 2, time.Second*3, false)
go_ping(ctx, "192.168.213.128", 2, time.Second*3, false)

//go.opencensus.io/trace.go

type Span struct {
	// data contains information recorded about the span.
	//
	// It will be non-nil if we are exporting the span or recording events for it.
	// Otherwise, data is nil, and the Span is simply a carrier for the
	// SpanContext, so that the trace ID is propagated.
	data        *SpanData
   // protects the contents of *data (but not the pointer value.)
	mu          sync.Mutex
	spanContext SpanContext
	// spanStore is the spanStore this span belongs to, if any, otherwise it is nil.
	*spanStore

	endOnce sync.Once

	executionTracerTaskEnd func()
}

type SpanContext struct {
	TraceID      TraceID
	SpanID       SpanID
	TraceOptions TraceOptions
}

func Background() Context

func WithCancel(parent Context) (ctx Context, cancel CancelFunc)

func WithDeadline(parent Context, deadline time.Time) (Context, CancelFunc)

func WithTimeout(parent Context, timeout time.Duration) (Context, CancelFunc)

func WithValue(parent Context, key interface{}, val interface{}) Context

conn, err := grpc.Dial(address, grpc.WithStatsHandler(&ocgrpc.ClientHandler{}), grpc.WithInsecure())
defer conn.Close()

c := pb.NewGreeterClient(conn)

...

for {
  r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
}

// SayHello implements helloworld.GreeterServer
func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
	ctx, span := trace.StartSpan(ctx, "sleep")
	time.Sleep(time.Duration(rand.Float64() * float64(time.Second)))
	span.End()
	return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

//go.opencensus.io/trace.go

// StartSpan starts a new child span of the current span in the context. If
// there is no span in the context, creates a new trace and span.
func StartSpan(ctx context.Context, name string, o ...StartOption) (context.Context, *Span) {
	var opts StartOptions
	var parent SpanContext
	if p := FromContext(ctx); p != nil {
		parent = p.spanContext
	}
	for _, op := range o {
		op(&opts)
	}
	span := startSpanInternal(name, parent != SpanContext{}, parent, false, opts)

	ctx, end := startExecutionTracerTask(ctx, name)
	span.executionTracerTaskEnd = end
	return NewContext(ctx, span), span
}

// FromContext returns the Span stored in a context, or nil if there isn't one.
func FromContext(ctx context.Context) *Span {
	s, _ := ctx.Value(contextKey{}).(*Span)
	return s
}

// source code : go.opencensus.io/view/worker.go

// Register begins collecting data for the given views.
// Once a view is subscribed, it reports data to the registered exporters.
func Register(views ...*View) error {
	for _, v := range views {
		if err := v.canonicalize(); err != nil {
			return err
		}
	}
	req := &registerViewReq{
		views: views,
		err:   make(chan error),
	}
	defaultWorker.c <- req
	return <-req.err
}

// source: go.opencensus.io/trace/export.go

// SpanData contains all the information collected by a Span.
type SpanData struct {
	SpanContext
	ParentSpanID SpanID
	SpanKind     int
	Name         string
	StartTime    time.Time
	// The wall clock time of EndTime will be adjusted to always be offset
	// from StartTime by the duration of the span.
	EndTime time.Time
	// The values of Attributes each have type string, bool, or int64.
	Attributes    map[string]interface{}
	Annotations   []Annotation
	MessageEvents []MessageEvent
	Status
	Links           []Link
	HasRemoteParent bool
}