package tracer import ( "context" "reflect" "go.unistack.org/micro/v4/logger" "go.unistack.org/micro/v4/options" rutil "go.unistack.org/micro/v4/util/reflect" ) type SpanStatus int const ( // SpanStatusUnset is the default status code. SpanStatusUnset SpanStatus = 0 // SpanStatusError indicates the operation contains an error. SpanStatusError SpanStatus = 1 // SpanStatusOK indicates operation has been validated by an Application developers // or Operator to have completed successfully, or contain no error. SpanStatusOK SpanStatus = 2 ) func (s SpanStatus) String() string { switch s { case SpanStatusUnset: return "Unset" case SpanStatusError: return "Error" case SpanStatusOK: return "OK" default: return "Unset" } } type SpanKind int const ( // SpanKindUnspecified is an unspecified SpanKind and is not a valid // SpanKind. SpanKindUnspecified should be replaced with SpanKindInternal // if it is received. SpanKindUnspecified SpanKind = 0 // SpanKindInternal is a SpanKind for a Span that represents an internal // operation within an application. SpanKindInternal SpanKind = 1 // SpanKindServer is a SpanKind for a Span that represents the operation // of handling a request from a client. SpanKindServer SpanKind = 2 // SpanKindClient is a SpanKind for a Span that represents the operation // of client making a request to a server. SpanKindClient SpanKind = 3 // SpanKindProducer is a SpanKind for a Span that represents the operation // of a producer sending a message to a message broker. Unlike // SpanKindClient and SpanKindServer, there is often no direct // relationship between this kind of Span and a SpanKindConsumer kind. A // SpanKindProducer Span will end once the message is accepted by the // message broker which might not overlap with the processing of that // message. SpanKindProducer SpanKind = 4 // SpanKindConsumer is a SpanKind for a Span that represents the operation // of a consumer receiving a message from a message broker. Like // SpanKindProducer Spans, there is often no direct relationship between // this Span and the Span that produced the message. SpanKindConsumer SpanKind = 5 ) func (sk SpanKind) String() string { switch sk { case SpanKindInternal: return "internal" case SpanKindServer: return "server" case SpanKindClient: return "client" case SpanKindProducer: return "producer" case SpanKindConsumer: return "consumer" default: return "unspecified" } } // SpanOptions contains span option type SpanOptions struct { Labels []interface{} Kind SpanKind } // EventOptions contains event options type EventOptions struct { Labels []interface{} } func WithSpanLabels(ls ...interface{}) options.Option { return func(src interface{}) error { v, err := options.Get(src, ".Labels") if err != nil { return err } else if rutil.IsZero(v) { v = reflect.MakeSlice(reflect.TypeOf(v), 0, len(ls)).Interface() } cv := reflect.ValueOf(v) for _, l := range ls { reflect.Append(cv, reflect.ValueOf(l)) } err = options.Set(src, cv, ".Labels") return err } } // EventOption func signature type EventOption func(o *EventOptions) func WithEventLabels(ls ...interface{}) options.Option { return func(src interface{}) error { v, err := options.Get(src, ".Labels") if err != nil { return err } else if rutil.IsZero(v) { v = reflect.MakeSlice(reflect.TypeOf(v), 0, len(ls)).Interface() } cv := reflect.ValueOf(v) for _, l := range ls { reflect.Append(cv, reflect.ValueOf(l)) } err = options.Set(src, cv, ".Labels") return err } } func WithSpanKind(k SpanKind) options.Option { return func(src interface{}) error { return options.Set(src, k, ".Kind") } } // Options struct type Options struct { // Context used to store custome tracer options Context context.Context // Logger used for logging Logger logger.Logger // Name of the tracer Name string } // NewSpanOptions returns default SpanOptions func NewSpanOptions(opts ...options.Option) SpanOptions { options := SpanOptions{ Kind: SpanKindInternal, } for _, o := range opts { o(&options) } return options } // NewOptions returns default options func NewOptions(opts ...options.Option) Options { options := Options{ Logger: logger.DefaultLogger, } for _, o := range opts { o(&options) } return options }