feat: add client tracing interceptor

Author: coderi421

gmicro/core/trace/attributes.go

@@ -0,0 +1,40 @@
+package trace
+
+import (
+	"go.opentelemetry.io/otel/attribute"
+	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
+	gcodes "google.golang.org/grpc/codes"
+)
+
+const (
+	// GRPCStatusCodeKey is convention for numeric status code of a gRPC request.
+	GRPCStatusCodeKey = attribute.Key("rpc.grpc.status_code")
+	// RPCNameKey is the name of message transmitted or received.
+	RPCNameKey = attribute.Key("name")
+	// RPCMessageTypeKey is the type of message transmitted or received.
+	RPCMessageTypeKey = attribute.Key("message.type")
+	// RPCMessageIDKey is the identifier of message transmitted or received.
+	RPCMessageIDKey = attribute.Key("message.id")
+	// RPCMessageCompressedSizeKey is the compressed size of the message transmitted or received in bytes.
+	RPCMessageCompressedSizeKey = attribute.Key("message.compressed_size")
+	// RPCMessageUncompressedSizeKey is the uncompressed size of the message
+	// transmitted or received in bytes.
+	RPCMessageUncompressedSizeKey = attribute.Key("message.uncompressed_size")
+)
+
+// Semantic conventions for common RPC attributes.
+var (
+	// RPCSystemGRPC is the semantic convention for gRPC as the remoting system.
+	RPCSystemGRPC = semconv.RPCSystemKey.String("grpc")
+	// RPCNameMessage is the semantic convention for a message named message.
+	RPCNameMessage = RPCNameKey.String("message")
+	// RPCMessageTypeSent is the semantic conventions for sent RPC message types.
+	RPCMessageTypeSent = RPCMessageTypeKey.String("SENT")
+	// RPCMessageTypeReceived is the semantic conventions for the received RPC message types.
+	RPCMessageTypeReceived = RPCMessageTypeKey.String("RECEIVED")
+)
+
+// StatusCodeAttr returns an attribute.KeyValue that represents the give c.
+func StatusCodeAttr(c gcodes.Code) attribute.KeyValue {
+	return GRPCStatusCodeKey.Int64(int64(c))
+}

gmicro/core/trace/message.go

@@ -0,0 +1,38 @@
+package trace
+
+import (
+	"context"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/trace"
+	"google.golang.org/protobuf/proto"
+)
+
+const messageEvent = "message"
+
+var (
+	// MessageSent is the type of sent messages.
+	MessageSent = messageType(RPCMessageTypeSent)
+	// MessageReceived is the type of received messages.
+	MessageReceived = messageType(RPCMessageTypeReceived)
+)
+
+type messageType attribute.KeyValue
+
+// Event adds an event of the messageType to the span associated with the
+// passed context with id and size (if message is a proto message).
+func (m messageType) Event(ctx context.Context, id int, message interface{}) {
+	span := trace.SpanFromContext(ctx)
+	if p, ok := message.(proto.Message); ok {
+		span.AddEvent(messageEvent, trace.WithAttributes(
+			attribute.KeyValue(m),
+			RPCMessageIDKey.Int(id),
+			RPCMessageUncompressedSizeKey.Int(proto.Size(p)),
+		))
+	} else {
+		span.AddEvent(messageEvent, trace.WithAttributes(
+			attribute.KeyValue(m),
+			RPCMessageIDKey.Int(id),
+		))
+	}
+}

gmicro/core/trace/options.go

@@ -1,5 +1,7 @@
 package trace
 
+//const TraceName = "gmicro"
+
 // Options 这个配置和 业务中 app 中的 tracing 冗余，为的是将 tracing 从业务中解耦出来
 type Options struct {
 	Name     string  `json:"name"`     // jeager 名称

gmicro/core/trace/tracer.go

@@ -0,0 +1,56 @@
+package trace
+
+import (
+	"context"
+
+	"go.opentelemetry.io/otel/baggage"
+	"go.opentelemetry.io/otel/propagation"
+	sdktrace "go.opentelemetry.io/otel/trace"
+	"google.golang.org/grpc/metadata"
+)
+
+// assert that metadataSupplier implements the TextMapCarrier interface
+var _ propagation.TextMapCarrier = (*metadataSupplier)(nil)
+
+type metadataSupplier struct {
+	metadata *metadata.MD
+}
+
+func (s *metadataSupplier) Get(key string) string {
+	values := s.metadata.Get(key)
+	if len(values) == 0 {
+		return ""
+	}
+
+	return values[0]
+}
+
+func (s *metadataSupplier) Set(key, value string) {
+	s.metadata.Set(key, value)
+}
+
+func (s *metadataSupplier) Keys() []string {
+	out := make([]string, 0, len(*s.metadata))
+	for key := range *s.metadata {
+		out = append(out, key)
+	}
+
+	return out
+}
+
+// Inject injects the metadata into ctx.
+func Inject(ctx context.Context, p propagation.TextMapPropagator, metadata *metadata.MD) {
+	p.Inject(ctx, &metadataSupplier{
+		metadata: metadata,
+	})
+}
+
+// Extract extracts the metadata from ctx.
+func Extract(ctx context.Context, p propagation.TextMapPropagator, metadata *metadata.MD) (
+	baggage.Baggage, sdktrace.SpanContext) {
+	ctx = p.Extract(ctx, &metadataSupplier{
+		metadata: metadata,
+	})
+
+	return baggage.FromContext(ctx), sdktrace.SpanContextFromContext(ctx)
+}

gmicro/core/trace/utils.go

@@ -0,0 +1,69 @@
+package trace
+
+import (
+	"context"
+	"net"
+	"strings"
+
+	"go.opentelemetry.io/otel/attribute"
+	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
+	"google.golang.org/grpc/peer"
+)
+
+const localhost = "127.0.0.1"
+
+// PeerFromCtx returns the peer from ctx.
+func PeerFromCtx(ctx context.Context) string {
+	p, ok := peer.FromContext(ctx)
+	if !ok || p == nil {
+		return ""
+	}
+
+	return p.Addr.String()
+}
+
+// SpanInfo returns the span info.
+func SpanInfo(fullMethod, peerAddress string) (string, []attribute.KeyValue) {
+	attrs := []attribute.KeyValue{RPCSystemGRPC}
+	name, mAttrs := ParseFullMethod(fullMethod)
+	attrs = append(attrs, mAttrs...)
+	attrs = append(attrs, PeerAttr(peerAddress)...)
+	return name, attrs
+}
+
+// ParseFullMethod returns the method name and attributes.
+func ParseFullMethod(fullMethod string) (string, []attribute.KeyValue) {
+	name := strings.TrimLeft(fullMethod, "/")
+	parts := strings.SplitN(name, "/", 2)
+	if len(parts) != 2 {
+		// Invalid format, does not follow `/package.service/method`.
+		return name, []attribute.KeyValue(nil)
+	}
+
+	var attrs []attribute.KeyValue
+	if service := parts[0]; service != "" {
+		attrs = append(attrs, semconv.RPCServiceKey.String(service))
+	}
+	if method := parts[1]; method != "" {
+		attrs = append(attrs, semconv.RPCMethodKey.String(method))
+	}
+
+	return name, attrs
+}
+
+// PeerAttr returns the peer attributes.
+func PeerAttr(addr string) []attribute.KeyValue {
+	host, port, err := net.SplitHostPort(addr)
+	if err != nil {
+		return nil
+	}
+
+	if len(host) == 0 {
+		host = localhost
+	}
+
+	return []attribute.KeyValue{
+		semconv.NetPeerIPKey.String(host),
+		semconv.NetPeerPortKey.String(port),
+	}
+}

gmicro/server/restserver/server.go

@@ -63,7 +63,7 @@ func NewServer(opts ...ServerOption) *Server {
 		jwt: &JwtInfo{
 			"JWT",
 			"Gd%YCfP1agNHo5x6xm2Qs33Bf!B#Gi!o",
-			7 * 24 * time.Hour,
+			1 * 24 * time.Hour,
 			7 * 24 * time.Hour,
 		},
 		Engine:    gin.Default(),