Valid OC proto traceID from 64bit ZipkinV2 traceID (#330)

* Valid OC proto traceID from 64bit ZipkinV2 traceID

* Revert go.mod and go.sum changes

Author: Paulo Janotti

receiver/zipkin/trace_receiver.go

@@ -18,7 +18,7 @@ import (
 	"compress/gzip"
 	"compress/zlib"
 	"context"
-	"encoding/hex"
+	"encoding/binary"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -282,28 +282,48 @@ func (zr *ZipkinReceiver) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusAccepted)
 }
 
-var errNilZipkinSpan = errors.New("non-nil Zipkin span expected")
+var (
+	errNilZipkinSpan = errors.New("non-nil Zipkin span expected")
+	errZeroTraceID   = errors.New("trace id is zero")
+	errZeroID        = errors.New("id is zero")
+)
 
-var blankIP net.IP
+func zTraceIDToOCProtoTraceID(zTraceID zipkinmodel.TraceID) ([]byte, error) {
+	if zTraceID.High == 0 && zTraceID.Low == 0 {
+		return nil, errZeroTraceID
+	}
+	traceID := make([]byte, 16)
+	binary.BigEndian.PutUint64(traceID[:8], uint64(zTraceID.High))
+	binary.BigEndian.PutUint64(traceID[8:], uint64(zTraceID.Low))
+	return traceID, nil
+}
+
+func zSpanIDToOCProtoSpanID(id zipkinmodel.ID) ([]byte, error) {
+	if id == 0 {
+		return nil, errZeroID
+	}
+	spanID := make([]byte, 8)
+	binary.BigEndian.PutUint64(spanID, uint64(id))
+	return spanID, nil
+}
 
 func zipkinSpanToTraceSpan(zs *zipkinmodel.SpanModel) (*tracepb.Span, *commonpb.Node, error) {
 	if zs == nil {
 		return nil, nil, errNilZipkinSpan
 	}
 
 	node := nodeFromZipkinEndpoints(zs)
-
-	traceID, err := hexStrToBytes(zs.TraceID.String())
+	traceID, err := zTraceIDToOCProtoTraceID(zs.TraceID)
 	if err != nil {
 		return nil, node, fmt.Errorf("TraceID: %v", err)
 	}
-	spanID, err := hexStrToBytes(zs.ID.String())
+	spanID, err := zSpanIDToOCProtoSpanID(zs.ID)
 	if err != nil {
 		return nil, node, fmt.Errorf("SpanID: %v", err)
 	}
 	var parentSpanID []byte
 	if zs.ParentID != nil {
-		parentSpanID, err = hexStrToBytes(zs.ParentID.String())
+		parentSpanID, err = zSpanIDToOCProtoSpanID(*zs.ParentID)
 		if err != nil {
 			return nil, node, fmt.Errorf("ParentSpanID: %v", err)
 		}
@@ -356,6 +376,8 @@ func nodeFromZipkinEndpoints(zs *zipkinmodel.SpanModel) *commonpb.Node {
 	return node
 }
 
+var blankIP net.IP
+
 func zipkinEndpointIntoAttributes(ep *zipkinmodel.Endpoint, into map[string]string, prefixFunc func(string) string) map[string]string {
 	if into == nil {
 		into = make(map[string]string)
@@ -420,13 +442,6 @@ var canonicalCodesMap = map[string]int32{
 	"UNAUTHENTICATED":     16,
 }
 
-func hexStrToBytes(hexStr string) ([]byte, error) {
-	if len(hexStr) == 0 {
-		return nil, nil
-	}
-	return hex.DecodeString(hexStr)
-}
-
 func zipkinSpanKindToProtoSpanKind(skind zipkinmodel.Kind) tracepb.Span_SpanKind {
 	switch strings.ToUpper(string(skind)) {
 	case "CLIENT":

receiver/zipkin/trace_receiver_test.go

@@ -27,6 +27,7 @@ import (
 	"time"
 
 	openzipkin "github.com/openzipkin/zipkin-go"
+	zipkinmodel "github.com/openzipkin/zipkin-go/model"
 	zhttp "github.com/openzipkin/zipkin-go/reporter/http"
 	"go.opencensus.io/exporter/zipkin"
 
@@ -40,6 +41,75 @@ import (
 	"github.com/census-instrumentation/opencensus-service/translator/trace"
 )
 
+func TestTraceIDConversion(t *testing.T) {
+	longID, _ := zipkinmodel.TraceIDFromHex("01020304050607080102030405060708")
+	shortID, _ := zipkinmodel.TraceIDFromHex("0102030405060708")
+	zeroID, _ := zipkinmodel.TraceIDFromHex("0000000000000000")
+	tests := []struct {
+		name    string
+		id      zipkinmodel.TraceID
+		want    []byte
+		wantErr error
+	}{
+		{
+			name:    "128bit traceID",
+			id:      longID,
+			want:    []byte{1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8},
+			wantErr: nil,
+		},
+		{
+			name:    "64bit traceID",
+			id:      shortID,
+			want:    []byte{0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8},
+			wantErr: nil,
+		},
+		{
+			name:    "zero traceID",
+			id:      zeroID,
+			want:    nil,
+			wantErr: errZeroTraceID,
+		},
+	}
+
+	for _, tc := range tests {
+		got, gotErr := zTraceIDToOCProtoTraceID(tc.id)
+		if tc.wantErr != gotErr {
+			t.Errorf("gotErr=%v wantErr=%v", gotErr, tc.wantErr)
+		}
+		if !reflect.DeepEqual(got, tc.want) {
+			t.Errorf("got=%v want=%v", got, tc.want)
+		}
+	}
+}
+
+func TestShortIDSpanConversion(t *testing.T) {
+	shortID, _ := zipkinmodel.TraceIDFromHex("0102030405060708")
+	if shortID.High != 0 {
+		t.Errorf("wanted 64bit traceID, so TraceID.High must be zero")
+	}
+
+	zc := zipkinmodel.SpanContext{
+		TraceID: shortID,
+		ID:      zipkinmodel.ID(shortID.Low),
+	}
+	zs := zipkinmodel.SpanModel{
+		SpanContext: zc,
+	}
+
+	ocSpan, _, err := zipkinSpanToTraceSpan(&zs)
+	if err != nil {
+		t.Fatalf("unexpected error %v", err)
+	}
+	if len(ocSpan.TraceId) != 16 {
+		t.Fatalf("incorrect OC proto trace id length")
+	}
+
+	want := []byte{0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8}
+	if !reflect.DeepEqual(ocSpan.TraceId, want) {
+		t.Errorf("got=%v want=%v", ocSpan.TraceId, want)
+	}
+}
+
 func TestConvertSpansToTraceSpans_json(t *testing.T) {
 	// Using Adrian Cole's sample at https://gist.github.com/adriancole/e8823c19dfed64e2eb71
 	blob, err := ioutil.ReadFile("./testdata/sample1.json")