Create & Init Project...

app/service/main/dapper/model/BUILD

@@ -0,0 +1,39 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "response.go",
+        "span.go",
+        "spanpoint.go",
+        "util.go",
+    ],
+    importpath = "go-common/app/service/main/dapper/model",
+    tags = ["manual"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "//library/net/trace/proto:go_default_library",
+        "@com_github_golang_protobuf//proto:go_default_library",
+        "@io_bazel_rules_go//proto/wkt:duration_go_proto",
+        "@io_bazel_rules_go//proto/wkt:timestamp_go_proto",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+    visibility = ["//visibility:public"],
+)

app/service/main/dapper/model/response.go

@@ -0,0 +1,15 @@
+package model
+
+// ClientStatusResp response clientstatus request just for debug
+type ClientStatusResp struct {
+	QueueLen int             `json:"queue_len"`
+	Clients  []*ClientStatus `json:"clients"`
+}
+
+// ClientStatus client status
+type ClientStatus struct {
+	Addr     string `json:"addr"`
+	UpTime   int64  `json:"up_time"`
+	ErrCount int64  `json:"err_count"`
+	Rate     int64  `json:"rate"`
+}

app/service/main/dapper/model/span.go

@@ -0,0 +1,142 @@
+package model
+
+import (
+	"strconv"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+
+	protogen "go-common/library/net/trace/proto"
+)
+
+// ProtoSpan alias to tgo-common/library/net/trace/proto.Span
+type ProtoSpan protogen.Span
+
+// RefType Kind
+const (
+	RefTypeChildOf int8 = iota
+	RefTypeFollowsFrom
+)
+
+// TagKind
+const (
+	TagString int8 = iota
+	TagInt
+	TagBool
+	TagFloat
+)
+
+// SpanRef describes causal relationship of the current span to another span (e.g. 'child-of')
+type SpanRef struct {
+	RefType int8
+	TraceID uint64
+	SpanID  uint64
+}
+
+// Tag span tag
+type Tag struct {
+	Kind  int8
+	Key   string
+	Value interface{}
+}
+
+// Field log field
+type Field struct {
+	Key   string
+	Value []byte
+}
+
+// Log span log
+type Log struct {
+	Timestamp int64
+	Fields    []Field
+}
+
+// Span represents a named unit of work performed by a service.
+type Span struct {
+	ServiceName   string
+	OperationName string
+	TraceID       uint64
+	SpanID        uint64
+	ParentID      uint64
+	Env           string
+	StartTime     time.Time
+	Duration      time.Duration
+	References    []SpanRef
+	Tags          map[string]interface{}
+	Logs          []Log
+	ProtoSpan     *ProtoSpan
+}
+
+// SetTag attach tag
+func (s *Span) SetTag(key string, value interface{}) error {
+	ptag, err := toProtoTag(key, value)
+	if err != nil {
+		return err
+	}
+	s.Tags[key] = value
+	s.ProtoSpan.Tags = append(s.ProtoSpan.Tags, ptag)
+	return nil
+}
+
+// SetOperationName .
+func (s *Span) SetOperationName(operationName string) {
+	s.OperationName = operationName
+	s.ProtoSpan.OperationName = operationName
+}
+
+// TraceIDStr return hex format trace_id
+func (s *Span) TraceIDStr() string {
+	return strconv.FormatUint(s.TraceID, 16)
+}
+
+// SpanIDStr return hex format span_id
+func (s *Span) SpanIDStr() string {
+	return strconv.FormatUint(s.SpanID, 16)
+}
+
+// ParentIDStr return hex format parent_id
+func (s *Span) ParentIDStr() string {
+	return strconv.FormatUint(s.ParentID, 16)
+}
+
+// IsServer span kind is server
+func (s *Span) IsServer() bool {
+	kind, ok := s.Tags["span.kind"].(string)
+	if !ok {
+		return false
+	}
+	return kind == "server"
+}
+
+// IsError is error happend
+func (s *Span) IsError() bool {
+	isErr, _ := s.Tags["error"].(bool)
+	return isErr
+}
+
+// StringTag get string type tag
+func (s *Span) StringTag(key string) string {
+	val, _ := s.Tags[key].(string)
+	return val
+}
+
+// BoolTag get string type tag
+func (s *Span) BoolTag(key string) bool {
+	val, _ := s.Tags[key].(bool)
+	return val
+}
+
+// GetTagString .
+func (s *Span) GetTagString(key string) string {
+	val, _ := s.Tags[key].(string)
+	return val
+}
+
+// Marshal return
+func (s *Span) Marshal() ([]byte, error) {
+	if s.ProtoSpan == nil {
+		return nil, nil
+	}
+	return proto.Marshal((*protogen.Span)(s.ProtoSpan))
+}

app/service/main/dapper/model/spanpoint.go

@@ -0,0 +1,24 @@
+package model
+
+// const for SpanPoint
+const ()
+
+// SamplePoint SamplePoint
+type SamplePoint struct {
+	TraceID uint64
+	SpanID  uint64
+	Value   int64
+}
+
+// SpanPoint contains time series
+type SpanPoint struct {
+	Timestamp     int64
+	ServiceName   string
+	OperationName string
+	PeerService   string
+	SpanKind      string
+	AvgDuration   SamplePoint // random sample point
+	MaxDuration   SamplePoint
+	MinDuration   SamplePoint
+	Errors        []SamplePoint
+}

app/service/main/dapper/model/util.go

@@ -0,0 +1,249 @@
+package model
+
+import (
+	"encoding/binary"
+	"fmt"
+	"math"
+	"strconv"
+	"time"
+
+	"github.com/golang/protobuf/ptypes/duration"
+	"github.com/golang/protobuf/ptypes/timestamp"
+
+	protogen "go-common/library/net/trace/proto"
+)
+
+const protoVersion2 int32 = 2
+
+// FromProtoSpan convert protogen.Span to model.Span
+func FromProtoSpan(protoSpan *ProtoSpan, parseLog bool) (*Span, error) {
+	var span *Span
+	var err error
+	if protoSpan.Version != protoVersion2 {
+		span, err = fromProtoSpanLeagcy(protoSpan, parseLog)
+	} else {
+		span, err = fromProtoSpanInternal(protoSpan, parseLog)
+	}
+	if err == nil {
+		// NOTE: !!
+		span.ProtoSpan = protoSpan
+	}
+	return span, err
+}
+
+func convertLeagcyTag(protoTag *protogen.Tag) Tag {
+	tag := Tag{Key: protoTag.Key}
+	switch protoTag.Kind {
+	case protogen.Tag_STRING:
+		tag.Kind = TagString
+		tag.Value = string(protoTag.Value)
+	case protogen.Tag_INT:
+		tag.Kind = TagInt
+		tag.Value, _ = strconv.ParseInt(string(protoTag.Value), 10, 64)
+	case protogen.Tag_BOOL:
+		tag.Kind = TagBool
+		tag.Value, _ = strconv.ParseBool(string(protoTag.Value))
+	case protogen.Tag_FLOAT:
+		tag.Kind = TagFloat
+		tag.Value, _ = strconv.ParseFloat(string(protoTag.Value), 64)
+	}
+	return tag
+}
+
+func convertLeagcyLog(protoLog *protogen.Log) Log {
+	log := Log{Timestamp: protoLog.Timestamp}
+	log.Fields = []Field{{Key: protoLog.Key, Value: protoLog.Value}}
+	return log
+}
+
+func fromProtoSpanLeagcy(protoSpan *ProtoSpan, parseLog bool) (*Span, error) {
+	span := &Span{
+		ServiceName:   protoSpan.ServiceName,
+		OperationName: protoSpan.OperationName,
+		TraceID:       protoSpan.TraceId,
+		SpanID:        protoSpan.SpanId,
+		Env:           protoSpan.Env,
+		ParentID:      protoSpan.ParentId,
+	}
+	span.StartTime = time.Unix(protoSpan.StartAt/int64(time.Second), protoSpan.StartAt%int64(time.Second))
+	span.Duration = time.Duration(protoSpan.FinishAt - protoSpan.StartAt)
+	span.References = []SpanRef{{
+		RefType: RefTypeChildOf,
+		TraceID: protoSpan.TraceId,
+		SpanID:  protoSpan.ParentId,
+	}}
+	span.Tags = make(map[string]interface{})
+	for _, tag := range protoSpan.Tags {
+		newTag := convertLeagcyTag(tag)
+		span.Tags[newTag.Key] = newTag.Value
+	}
+	if !parseLog {
+		return span, nil
+	}
+	span.Logs = make([]Log, 0, len(protoSpan.Logs))
+	for _, log := range protoSpan.Logs {
+		span.Logs = append(span.Logs, convertLeagcyLog(log))
+	}
+	return span, nil
+}
+
+func timeFromTimestamp(t *timestamp.Timestamp) time.Time {
+	return time.Unix(t.Seconds, int64(t.Nanos))
+}
+
+func durationFromDuration(d *duration.Duration) time.Duration {
+	return time.Duration(d.Seconds*int64(time.Second) + int64(d.Nanos))
+}
+
+func convertSpanRef(protoRef *protogen.SpanRef) SpanRef {
+	ref := SpanRef{
+		TraceID: protoRef.TraceId,
+		SpanID:  protoRef.SpanId,
+	}
+	switch protoRef.RefType {
+	case protogen.SpanRef_CHILD_OF:
+		ref.RefType = RefTypeChildOf
+	case protogen.SpanRef_FOLLOWS_FROM:
+		ref.RefType = RefTypeFollowsFrom
+	}
+	return ref
+}
+
+func unSerializeInt64(data []byte) int64 {
+	return int64(binary.BigEndian.Uint64(data))
+}
+
+func unSerializeBool(data []byte) bool {
+	return data[0] == byte(1)
+}
+
+func unSerializeFloat64(data []byte) float64 {
+	value := binary.BigEndian.Uint64(data)
+	return math.Float64frombits(value)
+}
+
+func convertTag(protoTag *protogen.Tag) Tag {
+	tag := Tag{Key: protoTag.Key}
+	switch protoTag.Kind {
+	case protogen.Tag_STRING:
+		tag.Kind = TagString
+		tag.Value = string(protoTag.Value)
+	case protogen.Tag_INT:
+		tag.Kind = TagInt
+		tag.Value = unSerializeInt64(protoTag.Value)
+	case protogen.Tag_BOOL:
+		tag.Kind = TagBool
+		tag.Value = unSerializeBool(protoTag.Value)
+	case protogen.Tag_FLOAT:
+		tag.Kind = TagFloat
+		tag.Value = unSerializeFloat64(protoTag.Value)
+	}
+	return tag
+}
+
+func convertLog(protoLog *protogen.Log) Log {
+	log := Log{Timestamp: protoLog.Timestamp}
+	log.Fields = make([]Field, 0, len(protoLog.Fields))
+	for _, protoFiled := range protoLog.Fields {
+		log.Fields = append(log.Fields, Field{Key: protoFiled.Key, Value: protoFiled.Value})
+	}
+	return log
+}
+
+func fromProtoSpanInternal(protoSpan *ProtoSpan, parseLog bool) (*Span, error) {
+	span := &Span{
+		ServiceName:   protoSpan.ServiceName,
+		OperationName: protoSpan.OperationName,
+		TraceID:       protoSpan.TraceId,
+		SpanID:        protoSpan.SpanId,
+		ParentID:      protoSpan.ParentId,
+		Env:           protoSpan.Env,
+		StartTime:     timeFromTimestamp(protoSpan.StartTime),
+		Duration:      durationFromDuration(protoSpan.Duration),
+	}
+	span.References = make([]SpanRef, 0, len(protoSpan.References))
+	for _, ref := range protoSpan.References {
+		span.References = append(span.References, convertSpanRef(ref))
+	}
+	span.Tags = make(map[string]interface{})
+	for _, tag := range protoSpan.Tags {
+		newTag := convertTag(tag)
+		span.Tags[newTag.Key] = newTag.Value
+	}
+	if !parseLog {
+		return span, nil
+	}
+	span.Logs = make([]Log, 0, len(protoSpan.Logs))
+	for _, log := range protoSpan.Logs {
+		span.Logs = append(span.Logs, convertLog(log))
+	}
+	return span, nil
+}
+
+// ParseProtoSpanTag tag
+func ParseProtoSpanTag(protoSpan *protogen.Span) map[string]interface{} {
+	tagMap := make(map[string]interface{})
+	var convertFn func(*protogen.Tag) Tag
+	if protoSpan.Version == protoVersion2 {
+		convertFn = convertTag
+	} else {
+		convertFn = convertLeagcyTag
+	}
+	for _, protoTag := range protoSpan.Tags {
+		tag := convertFn(protoTag)
+		tagMap[tag.Key] = tag.Value
+	}
+	return tagMap
+}
+
+func serializeInt64(v int64) []byte {
+	data := make([]byte, 8)
+	binary.BigEndian.PutUint64(data, uint64(v))
+	return data
+}
+
+func serializeFloat64(v float64) []byte {
+	data := make([]byte, 8)
+	binary.BigEndian.PutUint64(data, math.Float64bits(v))
+	return data
+}
+
+func serializeBool(v bool) []byte {
+	data := make([]byte, 1)
+	if v {
+		data[0] = byte(1)
+	} else {
+		data[0] = byte(0)
+	}
+	return data
+}
+
+func toProtoTag(key string, value interface{}) (*protogen.Tag, error) {
+	ptag := &protogen.Tag{Key: key}
+	switch value := value.(type) {
+	case string:
+		ptag.Kind = protogen.Tag_STRING
+		ptag.Value = []byte(value)
+	case int:
+		ptag.Kind = protogen.Tag_INT
+		ptag.Value = serializeInt64(int64(value))
+	case int32:
+		ptag.Kind = protogen.Tag_INT
+		ptag.Value = serializeInt64(int64(value))
+	case int64:
+		ptag.Kind = protogen.Tag_INT
+		ptag.Value = serializeInt64(value)
+	case bool:
+		ptag.Kind = protogen.Tag_BOOL
+		ptag.Value = serializeBool(value)
+	case float32:
+		ptag.Kind = protogen.Tag_BOOL
+		ptag.Value = serializeFloat64(float64(value))
+	case float64:
+		ptag.Kind = protogen.Tag_BOOL
+		ptag.Value = serializeFloat64(value)
+	default:
+		return nil, fmt.Errorf("invalid tag type %T", value)
+	}
+	return ptag, nil
+}