Create & Init Project...

app/service/main/dapper-query/model/BUILD

@@ -0,0 +1,42 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "const.go",
+        "rank.go",
+        "series.go",
+        "span.go",
+        "spanpoint.go",
+        "spanref.go",
+        "util.go",
+    ],
+    importpath = "go-common/app/service/main/dapper-query/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-query/model/const.go

@@ -0,0 +1,18 @@
+package model
+
+// RankType
+const (
+	MaxDurationRank = "max_duration"
+	MinDurationRank = "min_duration"
+	AvgDurationRank = "avg_duration"
+	ErrorsRank      = "errors"
+)
+
+// VerifyRankType .
+func VerifyRankType(rankType string) bool {
+	switch rankType {
+	case MaxDurationRank, MinDurationRank, AvgDurationRank, ErrorsRank:
+		return true
+	}
+	return false
+}

app/service/main/dapper-query/model/rank.go

@@ -0,0 +1,18 @@
+package model
+
+import (
+	"sort"
+)
+
+// MeanOperationNameValue .
+type MeanOperationNameValue struct {
+	Tag   map[string]string
+	Value float64
+}
+
+// SortRank Desc
+func SortRank(values []MeanOperationNameValue) {
+	sort.Slice(values, func(i, j int) bool {
+		return values[i].Value > values[j].Value
+	})
+}

app/service/main/dapper-query/model/series.go

@@ -0,0 +1,13 @@
+package model
+
+// SeriesItem .
+type SeriesItem struct {
+	Field string
+	Rows  []*float64
+}
+
+// Series data
+type Series struct {
+	Timestamps []int64
+	Items      []*SeriesItem
+}

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

@@ -0,0 +1,97 @@
+package model
+
+import (
+	"strconv"
+	"time"
+)
+
+// 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
+}
+
+// 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 value from tag
+func (s *Span) StringTag(key string) string {
+	val, _ := s.Tags[key].(string)
+	return val
+}

app/service/main/dapper-query/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-query/model/spanref.go

@@ -0,0 +1,23 @@
+package model
+
+import (
+	"strconv"
+)
+
+// SpanListRef .
+type SpanListRef struct {
+	TraceID  uint64
+	SpanID   uint64
+	IsError  bool
+	Duration int64
+}
+
+// TraceIDStr hex format traceid
+func (s SpanListRef) TraceIDStr() string {
+	return strconv.FormatUint(s.TraceID, 16)
+}
+
+// SpanIDStr hex format traceid
+func (s SpanListRef) SpanIDStr() string {
+	return strconv.FormatUint(s.SpanID, 16)
+}

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

@@ -0,0 +1,175 @@
+package model
+
+import (
+	"encoding/binary"
+	"math"
+	"strconv"
+	"time"
+
+	"github.com/golang/protobuf/proto"
+	"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(data []byte) (*Span, error) {
+	protoSpan := new(protogen.Span)
+	if err := proto.Unmarshal(data, protoSpan); err != nil {
+		return nil, err
+	}
+	var span *Span
+	var err error
+	if protoSpan.Version != protoVersion2 {
+		span, err = fromProtoSpanLeagcy(protoSpan)
+	} else {
+		span, err = fromProtoSpanInternal(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 *protogen.Span) (*Span, error) {
+	span := &Span{
+		ServiceName:   protoSpan.ServiceName,
+		OperationName: protoSpan.OperationName,
+		TraceID:       protoSpan.TraceId,
+		SpanID:        protoSpan.SpanId,
+		ParentID:      protoSpan.ParentId,
+		Env:           protoSpan.Env,
+	}
+	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
+	}
+	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 *protogen.Span) (*Span, error) {
+	span := &Span{
+		ServiceName:   protoSpan.ServiceName,
+		OperationName: protoSpan.OperationName,
+		TraceID:       protoSpan.TraceId,
+		SpanID:        protoSpan.SpanId,
+		Env:           protoSpan.Env,
+		ParentID:      protoSpan.ParentId,
+		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
+	}
+	span.Logs = make([]Log, 0, len(protoSpan.Logs))
+	for _, log := range protoSpan.Logs {
+		span.Logs = append(span.Logs, convertLog(log))
+	}
+	return span, nil
+}