wrapper

Documentation

Overview

Package wrapper provides wrapper for Tracer

Index

• Variables
• func ExtractDefaultLabels(md metadata.Metadata) []interface{}
• func NewClientCallWrapper(opts ...Option) client.CallWrapper
• func NewClientWrapper(opts ...Option) client.Wrapper
• func NewServerHandlerWrapper(opts ...Option) server.HandlerWrapper
• type ClientCallFuncObserver
• type ClientCallObserver
• type ClientStreamObserver
• type Option
  • func SkipEndpoins(eps ...string) Option
  • func WithClientCallFuncObservers(ob ...ClientCallFuncObserver) Option
  • func WithClientCallObservers(ob ...ClientCallObserver) Option
  • func WithClientStreamObservers(ob ...ClientStreamObserver) Option
  • func WithServerHandlerObservers(ob ...ServerHandlerObserver) Option
  • func WithTracer(t tracer.Tracer) Option
• type Options
  • func NewOptions(opts ...Option) Options
• type ServerHandlerObserver

Variables

var (
	DefaultClientCallObserver = func(ctx context.Context, req client.Request, rsp interface{}, opts []options.Option, sp tracer.Span, err error) {
		sp.SetName(fmt.Sprintf("Call %s.%s", req.Service(), req.Method()))
		var labels []interface{}
		if md, ok := metadata.FromOutgoingContext(ctx); ok {
			labels = append(labels, ExtractDefaultLabels(md)...)
		}
		if err != nil {
			sp.SetStatus(tracer.SpanStatusError, err.Error())
		}
		sp.AddLabels(labels...)
	}

	DefaultClientStreamObserver = func(ctx context.Context, req client.Request, opts []options.Option, stream client.Stream, sp tracer.Span, err error) {
		var labels []interface{}
		if md, ok := metadata.FromOutgoingContext(ctx); ok {
			labels = append(labels, ExtractDefaultLabels(md)...)
		}
		if err != nil {
			sp.SetStatus(tracer.SpanStatusError, err.Error())
		}
		sp.AddLabels(labels...)
	}

	DefaultServerHandlerObserver = func(ctx context.Context, req server.Request, rsp interface{}, sp tracer.Span, err error) {
		var labels []interface{}
		if md, ok := metadata.FromIncomingContext(ctx); ok {
			labels = append(labels, ExtractDefaultLabels(md)...)
		}
		if err != nil {
			sp.SetStatus(tracer.SpanStatusError, err.Error())
		}
		sp.AddLabels(labels...)
	}

	DefaultClientCallFuncObserver = func(ctx context.Context, addr string, req client.Request, rsp interface{}, opts client.CallOptions, sp tracer.Span, err error) {
		sp.SetName(fmt.Sprintf("%s.%s call", req.Service(), req.Method()))
		var labels []interface{}
		if md, ok := metadata.FromOutgoingContext(ctx); ok {
			labels = append(labels, ExtractDefaultLabels(md)...)
		}
		if err != nil {
			sp.SetStatus(tracer.SpanStatusError, err.Error())
		}
		sp.AddLabels(labels...)
	}

	DefaultSkipEndpoints = []string{"Meter.Metrics", "Health.Live", "Health.Ready", "Health.Version"}
)

var DefaultHeadersExctract = []string{metadata.HeaderTopic, metadata.HeaderEndpoint, metadata.HeaderService, metadata.HeaderXRequestID}

Functions

func ExtractDefaultLabels

func ExtractDefaultLabels(md metadata.Metadata) []interface{}

func NewClientCallWrapper

func NewClientCallWrapper(opts ...Option) client.CallWrapper

NewClientCallWrapper accepts an opentracing Tracer and returns a Call Wrapper

func NewClientWrapper

func NewClientWrapper(opts ...Option) client.Wrapper

NewClientWrapper accepts an open tracing Trace and returns a Client Wrapper

func NewServerHandlerWrapper

func NewServerHandlerWrapper(opts ...Option) server.HandlerWrapper

NewServerHandlerWrapper accepts an options and returns a Handler Wrapper

Types

type ClientCallFuncObserver

type ClientCallFuncObserver func(context.Context, string, client.Request, interface{}, client.CallOptions, tracer.Span, error)

type ClientCallObserver

type ClientCallObserver func(context.Context, client.Request, interface{}, []options.Option, tracer.Span, error)

type ClientStreamObserver

type ClientStreamObserver func(context.Context, client.Request, []options.Option, client.Stream, tracer.Span, error)

type Option

type Option func(*Options)

Option func signature

func SkipEndpoins

func SkipEndpoins(eps ...string) Option

SkipEndponts

func WithClientCallFuncObservers

func WithClientCallFuncObservers(ob ...ClientCallFuncObserver) Option

WithClientCallFuncObservers funcs

func WithClientCallObservers

func WithClientCallObservers(ob ...ClientCallObserver) Option

WithClientCallObservers funcs

func WithClientStreamObservers

func WithClientStreamObservers(ob ...ClientStreamObserver) Option

WithClientStreamObservers funcs

func WithServerHandlerObservers

func WithServerHandlerObservers(ob ...ServerHandlerObserver) Option

WithServerHandlerObservers funcs

func WithTracer

func WithTracer(t tracer.Tracer) Option

WithTracer pass tracer

type Options

type Options struct {
	// Tracer that used for tracing
	Tracer tracer.Tracer
	// ClientCallObservers funcs
	ClientCallObservers []ClientCallObserver
	// ClientStreamObservers funcs
	ClientStreamObservers []ClientStreamObserver
	// ClientCallFuncObservers funcs
	ClientCallFuncObservers []ClientCallFuncObserver
	// ServerHandlerObservers funcs
	ServerHandlerObservers []ServerHandlerObserver
	// SkipEndpoints
	SkipEndpoints []string
}

Options struct

func NewOptions

func NewOptions(opts ...Option) Options

NewOptions create Options from Option slice

type ServerHandlerObserver

type ServerHandlerObserver func(context.Context, server.Request, interface{}, tracer.Span, error)