From 75b1ac14fb070d2a17d1944350a9632f6b368793 Mon Sep 17 00:00:00 2001
From: Tigran Najaryan <4194920+tigrannajaryan@users.noreply.github.com>
Date: Thu, 24 Sep 2020 10:13:42 -0400
Subject: [PATCH] Use custom data type and custom JSON serialization for
 traceid (#1840)

Contributes to https://github.com/open-telemetry/opentelemetry-collector/issues/1177

1. The TraceID type uses custom data type so that JSON serialization
is in hex format instead of base64 (which is the default Protobuf JSON
format). Hex format is required by OTLP spec:
https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/protocol/otlp.md#request
SpanID must be also modified similarly. Will be done in a future PR
to avoid creating a huge PR.

2. Moved pdata.TraceID to its own file. Note that there is pdata.TraceID which
is different from otlp TraceID custom data type. Due to the way packages are
structured we need both to keep OTLP generated data types decoupled from pdata
data types.

The majority of the changes in this commit are simply type changes from
[]byte to TraceID.
---
 Makefile                                      |   3 +
 cmd/pdatagen/internal/log_structs.go          |   1 +
 cmd/pdatagen/internal/trace_structs.go        |   3 +-
 consumer/pdata/generated_log.go               |   3 +-
 consumer/pdata/generated_trace.go             |   5 +-
 consumer/pdata/metric_test.go                 |   2 +-
 consumer/pdata/trace.go                       |  11 -
 consumer/pdata/trace_test.go                  |   2 +-
 consumer/pdata/traceid.go                     |  34 +++
 exporter/jaegerexporter/exporter_test.go      |   5 +-
 exporter/loggingexporter/logging_exporter.go  |   4 +-
 .../logs/v1/logs.pb.go                        | 144 ++++++------
 .../metrics/v1/metrics.pb.go                  | 216 +++++++++---------
 .../trace/v1/trace.pb.go                      | 216 +++++++++---------
 internal/data/testdata/log.go                 |   4 +-
 internal/goldendataset/generator_commons.go   |   4 +-
 internal/goldendataset/span_generator.go      |   6 +-
 processor/groupbytraceprocessor/processor.go  |  29 ++-
 .../groupbytraceprocessor/processor_test.go   |  40 ++--
 .../groupbytraceprocessor/ring_buffer.go      |  10 +-
 .../groupbytraceprocessor/ring_buffer_test.go |  12 +-
 .../groupbytraceprocessor/storage_memory.go   |   6 +-
 .../storage_memory_test.go                    |  10 +-
 .../probabilisticsampler.go                   |   2 +-
 .../probabilisticsampler_test.go              |   4 +-
 .../idbatcher/id_batcher.go                   |  17 +-
 .../idbatcher/id_batcher_test.go              |  13 +-
 .../tailsamplingprocessor/processor.go        |   6 +-
 .../tailsamplingprocessor/processor_test.go   |  18 +-
 .../sampling/always_sample.go                 |   6 +-
 .../sampling/numeric_tag_filter.go            |   6 +-
 .../sampling/numeric_tag_filter_test.go       |   3 +-
 .../tailsamplingprocessor/sampling/policy.go  |   5 +-
 .../sampling/rate_limiting.go                 |   6 +-
 .../sampling/string_tag_filter.go             |   6 +-
 .../sampling/string_tag_filter_test.go        |   3 +-
 proto_patch.sed                               |   8 +
 receiver/jaegerreceiver/jaeger_agent_test.go  |   2 +-
 .../jaegerreceiver/trace_receiver_test.go     |   2 +-
 receiver/otlpreceiver/logs/otlp_test.go       |   3 +-
 receiver/otlpreceiver/marshal_jsonpb_test.go  |   1 +
 receiver/otlpreceiver/otlp_test.go            | 216 ++++++++++++------
 receiver/otlpreceiver/trace/otlp_test.go      |   3 +-
 receiver/zipkinreceiver/proto_parse_test.go   |   4 +-
 service/internal/resources.go                 |  12 +-
 testbed/testbed/data_providers.go             |  16 +-
 testbed/testbed/validator.go                  |   8 +-
 translator/internaldata/oc_to_traces.go       |   1 +
 translator/trace/big_endian_converter.go      |  22 ++
 .../trace/jaeger/jaegerproto_to_traces.go     |   4 +-
 .../trace/jaeger/jaegerthrift_to_traces.go    |   4 +-
 .../trace/jaeger/traces_to_jaegerproto.go     |   2 +-
 translator/trace/zipkin/traces_to_zipkinv2.go |   4 +-
 translator/trace/zipkin/zipkinv2_to_traces.go |   7 +-
 .../trace/zipkin/zipkinv2_to_traces_test.go   |   8 +-
 55 files changed, 662 insertions(+), 530 deletions(-)
 create mode 100644 consumer/pdata/traceid.go

diff --git a/Makefile b/Makefile
index 7689b19b500..57d5c7b3fb5 100644
--- a/Makefile
+++ b/Makefile
@@ -277,6 +277,9 @@ genproto_sub:
 	sed -f proto_patch.sed $(OPENTELEMETRY_PROTO_SRC_DIR)/opentelemetry/proto/logs/v1/logs.proto \
 	   > $(PROTO_INTERMEDIATE_DIR)/opentelemetry/proto/logs/v1/logs.proto
 
+	sed -f proto_patch.sed $(OPENTELEMETRY_PROTO_SRC_DIR)/opentelemetry/proto/metrics/v1/metrics.proto \
+	   > $(PROTO_INTERMEDIATE_DIR)/opentelemetry/proto/metrics/v1/metrics.proto
+
 	@echo Generate Go code from .proto files in intermediate directory.
 	$(foreach file,$(OPENTELEMETRY_PROTO_FILES),$(call exec-command,cd $(PROTO_INTERMEDIATE_DIR) && protoc --gogofaster_out=plugins=grpc:./ -I./ -I$(GO_PKG_DIR) $(file)))
 
diff --git a/cmd/pdatagen/internal/log_structs.go b/cmd/pdatagen/internal/log_structs.go
index 5b599f8c588..56085dd74e4 100644
--- a/cmd/pdatagen/internal/log_structs.go
+++ b/cmd/pdatagen/internal/log_structs.go
@@ -17,6 +17,7 @@ package internal
 var logFile = &File{
 	Name: "log",
 	imports: []string{
+		`otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"`,
 		`otlplogs "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/logs/v1"`,
 	},
 	testImports: []string{
diff --git a/cmd/pdatagen/internal/trace_structs.go b/cmd/pdatagen/internal/trace_structs.go
index 16017c61c3d..54449fade92 100644
--- a/cmd/pdatagen/internal/trace_structs.go
+++ b/cmd/pdatagen/internal/trace_structs.go
@@ -17,6 +17,7 @@ package internal
 var traceFile = &File{
 	Name: "trace",
 	imports: []string{
+		`otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"`,
 		`otlptrace "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/trace/v1"`,
 	},
 	testImports: []string{
@@ -204,7 +205,7 @@ var traceIDField = &primitiveTypedField{
 	fieldName:       "TraceID",
 	originFieldName: "TraceId",
 	returnType:      "TraceID",
-	rawType:         "[]byte",
+	rawType:         "otlpcommon.TraceID",
 	defaultVal:      "NewTraceID(nil)",
 	testVal:         "NewTraceID([]byte{1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1})",
 }
diff --git a/consumer/pdata/generated_log.go b/consumer/pdata/generated_log.go
index 9b055336ab0..c48f949e92a 100644
--- a/consumer/pdata/generated_log.go
+++ b/consumer/pdata/generated_log.go
@@ -18,6 +18,7 @@
 package pdata
 
 import (
+	otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	otlplogs "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/logs/v1"
 )
 
@@ -590,7 +591,7 @@ func (ms LogRecord) TraceID() TraceID {
 //
 // Important: This causes a runtime error if IsNil() returns "true".
 func (ms LogRecord) SetTraceID(v TraceID) {
-	(*ms.orig).TraceId = []byte(v)
+	(*ms.orig).TraceId = otlpcommon.TraceID(v)
 }
 
 // SpanID returns the spanid associated with this LogRecord.
diff --git a/consumer/pdata/generated_trace.go b/consumer/pdata/generated_trace.go
index 8841ad90fa3..d5eec86e535 100644
--- a/consumer/pdata/generated_trace.go
+++ b/consumer/pdata/generated_trace.go
@@ -18,6 +18,7 @@
 package pdata
 
 import (
+	otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	otlptrace "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/trace/v1"
 )
 
@@ -576,7 +577,7 @@ func (ms Span) TraceID() TraceID {
 //
 // Important: This causes a runtime error if IsNil() returns "true".
 func (ms Span) SetTraceID(v TraceID) {
-	(*ms.orig).TraceId = []byte(v)
+	(*ms.orig).TraceId = otlpcommon.TraceID(v)
 }
 
 // SpanID returns the spanid associated with this Span.
@@ -1175,7 +1176,7 @@ func (ms SpanLink) TraceID() TraceID {
 //
 // Important: This causes a runtime error if IsNil() returns "true".
 func (ms SpanLink) SetTraceID(v TraceID) {
-	(*ms.orig).TraceId = []byte(v)
+	(*ms.orig).TraceId = otlpcommon.TraceID(v)
 }
 
 // SpanID returns the spanid associated with this SpanLink.
diff --git a/consumer/pdata/metric_test.go b/consumer/pdata/metric_test.go
index 8cad1e17b98..48299701d52 100644
--- a/consumer/pdata/metric_test.go
+++ b/consumer/pdata/metric_test.go
@@ -156,7 +156,7 @@ func TestResourceMetricsWireCompatibility(t *testing.T) {
 
 	// Now compare that the original and final ProtoBuf messages are the same.
 	// This proves that goproto and gogoproto marshaling/unmarshaling are wire compatible.
-	assert.True(t, gogoproto.Equal(*pdataRM.orig, &gogoprotoRM))
+	assert.True(t, assert.EqualValues(t, *pdataRM.orig, &gogoprotoRM))
 }
 
 func TestMetricCount(t *testing.T) {
diff --git a/consumer/pdata/trace.go b/consumer/pdata/trace.go
index 2483bcd3c4e..e4b962b4b4a 100644
--- a/consumer/pdata/trace.go
+++ b/consumer/pdata/trace.go
@@ -105,17 +105,6 @@ func (td Traces) ResourceSpans() ResourceSpansSlice {
 	return newResourceSpansSlice(td.orig)
 }
 
-type TraceID []byte
-
-// NewTraceID returns a new TraceID.
-func NewTraceID(bytes []byte) TraceID { return bytes }
-
-func (t TraceID) Bytes() []byte {
-	return t
-}
-
-func (t TraceID) String() string { return hex.EncodeToString(t) }
-
 type SpanID []byte
 
 // NewSpanID returns a new SpanID.
diff --git a/consumer/pdata/trace_test.go b/consumer/pdata/trace_test.go
index 499b0fc1274..0d00d1f2ef9 100644
--- a/consumer/pdata/trace_test.go
+++ b/consumer/pdata/trace_test.go
@@ -140,7 +140,7 @@ func TestResourceSpansWireCompatibility(t *testing.T) {
 
 	// Now compare that the original and final ProtoBuf messages are the same.
 	// This proves that goproto and gogoproto marshaling/unmarshaling are wire compatible.
-	assert.True(t, gogoproto.Equal(*pdataRS.orig, &gogoprotoRS2))
+	assert.EqualValues(t, *pdataRS.orig, &gogoprotoRS2)
 }
 
 func TestTraces_ToOtlpProtoBytes(t *testing.T) {
diff --git a/consumer/pdata/traceid.go b/consumer/pdata/traceid.go
new file mode 100644
index 00000000000..a5c63cfdd2e
--- /dev/null
+++ b/consumer/pdata/traceid.go
@@ -0,0 +1,34 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package pdata
+
+import (
+	otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
+)
+
+// TraceID is an alias of OTLP TraceID data type.
+type TraceID otlpcommon.TraceID
+
+func NewTraceID(bytes []byte) TraceID {
+	return TraceID(otlpcommon.NewTraceID(bytes))
+}
+
+func (t TraceID) Bytes() []byte {
+	return otlpcommon.TraceID(t).Bytes()
+}
+
+func (t TraceID) HexString() string {
+	return otlpcommon.TraceID(t).HexString()
+}
diff --git a/exporter/jaegerexporter/exporter_test.go b/exporter/jaegerexporter/exporter_test.go
index b441d8de099..c9ed79a43c4 100644
--- a/exporter/jaegerexporter/exporter_test.go
+++ b/exporter/jaegerexporter/exporter_test.go
@@ -32,6 +32,7 @@ import (
 	"go.opentelemetry.io/collector/config/configgrpc"
 	"go.opentelemetry.io/collector/config/configtls"
 	"go.opentelemetry.io/collector/consumer/pdata"
+	otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	tracev1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/trace/v1"
 	"go.opentelemetry.io/collector/internal/data/testdata"
 )
@@ -226,7 +227,7 @@ func TestMutualTLS(t *testing.T) {
 	require.NoError(t, err)
 	defer exporter.Shutdown(context.Background())
 
-	traceID := []byte("0123456789abcdef")
+	traceID := otlpcommon.NewTraceID([]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15})
 	spanID := []byte("01234567")
 	traces := pdata.TracesFromOtlp([]*tracev1.ResourceSpans{
 		{InstrumentationLibrarySpans: []*tracev1.InstrumentationLibrarySpans{{Spans: []*tracev1.Span{{TraceId: traceID, SpanId: spanID}}}}},
@@ -235,7 +236,7 @@ func TestMutualTLS(t *testing.T) {
 	require.NoError(t, err)
 	requestes := spanHandler.getRequests()
 	assert.Equal(t, 1, len(requestes))
-	jTraceID, err := model.TraceIDFromBytes(traceID)
+	jTraceID, err := model.TraceIDFromBytes(traceID.Bytes())
 	require.NoError(t, err)
 	assert.Equal(t, jTraceID, requestes[0].GetBatch().Spans[0].TraceID)
 }
diff --git a/exporter/loggingexporter/logging_exporter.go b/exporter/loggingexporter/logging_exporter.go
index 7ad4feb3553..d6d2b58a126 100644
--- a/exporter/loggingexporter/logging_exporter.go
+++ b/exporter/loggingexporter/logging_exporter.go
@@ -254,7 +254,7 @@ func (b *logDataBuffer) logLinks(description string, sl pdata.SpanLinkSlice) {
 			continue
 		}
 		b.logEntry("SpanLink #%d", i)
-		b.logEntry("     -> Trace ID: %s", l.TraceID().String())
+		b.logEntry("     -> Trace ID: %s", l.TraceID().HexString())
 		b.logEntry("     -> ID: %s", l.SpanID().String())
 		b.logEntry("     -> TraceState: %s", l.TraceState())
 		b.logEntry("     -> DroppedAttributesCount: %d", l.DroppedAttributesCount())
@@ -332,7 +332,7 @@ func (s *loggingExporter) pushTraceData(
 					continue
 				}
 
-				buf.logAttr("Trace ID", span.TraceID().String())
+				buf.logAttr("Trace ID", span.TraceID().HexString())
 				buf.logAttr("Parent ID", span.ParentSpanID().String())
 				buf.logAttr("ID", span.SpanID().String())
 				buf.logAttr("Name", span.Name())
diff --git a/internal/data/opentelemetry-proto-gen/logs/v1/logs.pb.go b/internal/data/opentelemetry-proto-gen/logs/v1/logs.pb.go
index 7451f9227e4..eb42c2a6556 100644
--- a/internal/data/opentelemetry-proto-gen/logs/v1/logs.pb.go
+++ b/internal/data/opentelemetry-proto-gen/logs/v1/logs.pb.go
@@ -13,6 +13,7 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 
+	go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v11 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/resource/v1"
 )
@@ -296,7 +297,7 @@ type LogRecord struct {
 	// the same `trace_id`. The ID is a 16-byte array. An ID with all zeroes
 	// is considered invalid. Can be set for logs that are part of request processing
 	// and have an assigned trace id. [Optional].
-	TraceId []byte `protobuf:"bytes,9,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	TraceId go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1.TraceID `protobuf:"bytes,9,opt,name=trace_id,json=traceId,proto3,customtype=go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1.TraceID" json:"trace_id"`
 	// A unique identifier for a span within a trace, assigned when the span
 	// is created. The ID is an 8-byte array. An ID with all zeroes is considered
 	// invalid. Can be set for logs that are part of a particular processing span.
@@ -393,13 +394,6 @@ func (m *LogRecord) GetFlags() uint32 {
 	return 0
 }
 
-func (m *LogRecord) GetTraceId() []byte {
-	if m != nil {
-		return m.TraceId
-	}
-	return nil
-}
-
 func (m *LogRecord) GetSpanId() []byte {
 	if m != nil {
 		return m.SpanId
@@ -420,59 +414,61 @@ func init() {
 }
 
 var fileDescriptor_d1c030a3ec7e961e = []byte{
-	// 829 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x95, 0xdf, 0x6e, 0xe2, 0x46,
-	0x14, 0xc6, 0x33, 0x09, 0x81, 0x64, 0x42, 0xd8, 0xe9, 0x34, 0x9b, 0x78, 0x49, 0xc5, 0xa2, 0xb4,
-	0xdd, 0xd2, 0x54, 0x6b, 0x84, 0xa1, 0x6a, 0xd5, 0xde, 0x94, 0x24, 0x26, 0x42, 0x61, 0x49, 0x34,
-	0x90, 0xed, 0x9f, 0x1b, 0xcb, 0xc0, 0xac, 0x6b, 0xc9, 0x9e, 0x41, 0xf6, 0x18, 0x85, 0xb7, 0xa8,
-	0xfa, 0x4a, 0xbd, 0x59, 0xf5, 0x2a, 0x97, 0xbd, 0xac, 0x92, 0x07, 0x69, 0xe5, 0x31, 0xb0, 0x0b,
-	0xf2, 0x90, 0x2b, 0xce, 0x9c, 0xdf, 0xf7, 0x9d, 0x73, 0xe6, 0xc8, 0xd8, 0xf0, 0x15, 0x1f, 0x53,
-	0x26, 0xa8, 0x47, 0x7d, 0x2a, 0x82, 0x69, 0x75, 0x1c, 0x70, 0xc1, 0xab, 0x1e, 0x77, 0xc2, 0xea,
-	0xa4, 0x26, 0x7f, 0x75, 0x99, 0xc2, 0xc7, 0x4b, 0xba, 0x24, 0xa9, 0x4b, 0x3e, 0xa9, 0x15, 0x1b,
-	0x8e, 0x2b, 0x7e, 0x8f, 0x06, 0xfa, 0x90, 0xfb, 0x55, 0x87, 0x3b, 0x3c, 0x29, 0x33, 0x88, 0xde,
-	0xfd, 0x34, 0xa9, 0xe9, 0x75, 0xbd, 0x26, 0x93, 0x49, 0xe9, 0x38, 0x4a, 0xdc, 0xc5, 0xd3, 0xb4,
-	0xd6, 0x43, 0xee, 0xfb, 0x9c, 0xc5, 0xcd, 0x93, 0x68, 0xa6, 0xd5, 0xd3, 0xb4, 0x01, 0x0d, 0x79,
-	0x14, 0x0c, 0x69, 0xac, 0x9e, 0xc7, 0x89, 0xfe, 0xe4, 0x1e, 0xc0, 0x3c, 0x99, 0xa5, 0x3a, 0xdc,
-	0x09, 0xb1, 0x09, 0x77, 0xe6, 0x12, 0x0d, 0x94, 0x41, 0x65, 0xcf, 0xf8, 0x5a, 0x4f, 0xbb, 0xd2,
-	0xa2, 0xce, 0xa4, 0xa6, 0xcf, 0x0b, 0x90, 0x85, 0x15, 0x4f, 0xe1, 0x67, 0x2e, 0x0b, 0x45, 0x10,
-	0xf9, 0x94, 0x09, 0x5b, 0xb8, 0x9c, 0x59, 0x9e, 0x3b, 0x08, 0xec, 0x60, 0x6a, 0xc5, 0xcb, 0xd0,
-	0x36, 0xcb, 0x5b, 0x95, 0x3d, 0xe3, 0x3b, 0x7d, 0xcd, 0xb6, 0xf4, 0xf6, 0x72, 0x81, 0x4e, 0xe2,
-	0x8f, 0xa7, 0x24, 0x45, 0x57, 0xc9, 0x4e, 0xde, 0x03, 0x58, 0x54, 0x5b, 0x31, 0x83, 0x47, 0x8a,
-	0xc9, 0x66, 0xf7, 0xfd, 0x36, 0x75, 0xa8, 0xd9, 0x96, 0x95, 0x63, 0x91, 0xc3, 0xf4, 0x91, 0xf0,
-	0x0f, 0x30, 0xf3, 0xd1, 0x8d, 0x5f, 0xad, 0xbd, 0x71, 0x87, 0x3b, 0x84, 0x0e, 0x79, 0x30, 0x22,
-	0xd2, 0x73, 0xf2, 0xf7, 0x16, 0xdc, 0x5d, 0xe4, 0xf0, 0x17, 0xb0, 0x20, 0x5c, 0x9f, 0x5a, 0x11,
-	0x73, 0xef, 0x2c, 0x66, 0x33, 0x2e, 0x07, 0xce, 0x92, 0x7c, 0x9c, 0xbd, 0x65, 0xee, 0x5d, 0xd7,
-	0x66, 0x1c, 0xf7, 0xe1, 0xb3, 0x90, 0x4e, 0x68, 0xe0, 0x8a, 0xa9, 0xc5, 0x22, 0x7f, 0x40, 0x03,
-	0x6d, 0xb3, 0x0c, 0x2a, 0x05, 0xe3, 0x9b, 0xb5, 0xad, 0x7b, 0x33, 0x4f, 0x57, 0x5a, 0x48, 0x21,
-	0x5c, 0x3a, 0xe3, 0xcf, 0xe1, 0xfe, 0xa2, 0xaa, 0xa0, 0x77, 0x42, 0xdb, 0x2a, 0x83, 0xca, 0x2e,
-	0xc9, 0xcf, 0x93, 0x7d, 0x7a, 0x27, 0x30, 0x86, 0x19, 0x66, 0xfb, 0x54, 0xcb, 0x48, 0x26, 0x63,
-	0xfc, 0x23, 0xcc, 0x0c, 0xf8, 0x68, 0xaa, 0x6d, 0xcb, 0xdd, 0x7e, 0xf5, 0xc4, 0x6e, 0x9b, 0x6c,
-	0xfa, 0xd6, 0xf6, 0x22, 0x4a, 0xa4, 0x09, 0x5f, 0x42, 0x68, 0x0b, 0x11, 0xb8, 0x83, 0x48, 0xd0,
-	0x50, 0xcb, 0xca, 0x0d, 0x3e, 0x55, 0xe2, 0x8a, 0xce, 0x4a, 0x7c, 0x64, 0xc5, 0xdf, 0x43, 0x6d,
-	0x14, 0xf0, 0xf1, 0x98, 0x8e, 0xac, 0x0f, 0x59, 0x6b, 0xc8, 0x23, 0x26, 0xb4, 0x5c, 0x19, 0x54,
-	0xf6, 0xc9, 0xe1, 0x8c, 0x37, 0x17, 0xf8, 0x3c, 0xa6, 0xf8, 0x00, 0x6e, 0xbf, 0xf3, 0x6c, 0x27,
-	0xd4, 0x76, 0xca, 0xa0, 0x92, 0x23, 0xc9, 0x01, 0xbf, 0x80, 0x3b, 0x22, 0xb0, 0x87, 0xd4, 0x72,
-	0x47, 0xda, 0x6e, 0x19, 0x54, 0xf2, 0x24, 0x27, 0xcf, 0xed, 0x11, 0x3e, 0x82, 0xb9, 0x70, 0x6c,
-	0xb3, 0x98, 0x40, 0x49, 0xb2, 0xf1, 0xb1, 0x3d, 0x3a, 0xfd, 0x6b, 0x1b, 0x16, 0x96, 0xb7, 0x8c,
-	0x5f, 0xc2, 0xe3, 0x9e, 0xf9, 0xd6, 0x24, 0xed, 0xfe, 0xaf, 0x56, 0xf7, 0xf6, 0xcd, 0x99, 0x49,
-	0xac, 0xdb, 0x6e, 0xef, 0xc6, 0x3c, 0x6f, 0xb7, 0xda, 0xe6, 0x05, 0xda, 0xc0, 0x2f, 0xe0, 0xf3,
-	0x55, 0x41, 0x9f, 0x34, 0xcf, 0x4d, 0x04, 0x70, 0x11, 0x1e, 0xa6, 0x22, 0x03, 0x6d, 0x2a, 0x59,
-	0x1d, 0x6d, 0x29, 0x59, 0x03, 0x65, 0xd2, 0xda, 0x5d, 0x98, 0x67, 0xb7, 0x97, 0x68, 0x3b, 0xcd,
-	0x26, 0x91, 0x81, 0xb2, 0x4a, 0x56, 0x47, 0x39, 0x25, 0x6b, 0xa0, 0x1d, 0xac, 0xc1, 0x83, 0x55,
-	0xd6, 0xee, 0xb6, 0xae, 0xd1, 0x6e, 0xda, 0x20, 0x31, 0x31, 0x10, 0x54, 0xa1, 0x3a, 0xda, 0x53,
-	0xa1, 0x06, 0xca, 0xa7, 0xb5, 0xfa, 0xb9, 0x49, 0xba, 0x68, 0x3f, 0xcd, 0x14, 0x13, 0x03, 0x15,
-	0x54, 0xa8, 0x8e, 0x9e, 0xa9, 0x50, 0x03, 0xa1, 0x34, 0x64, 0x12, 0x72, 0x4d, 0xd0, 0x27, 0x69,
-	0xcb, 0x90, 0xc8, 0x40, 0x58, 0xc9, 0xea, 0xe8, 0x53, 0x25, 0x6b, 0xa0, 0x83, 0xb4, 0x76, 0xad,
-	0x66, 0xbf, 0xd9, 0x41, 0xcf, 0xd3, 0x6c, 0x12, 0x19, 0xe8, 0x50, 0xc9, 0xea, 0xe8, 0x48, 0xc9,
-	0x1a, 0x48, 0x3b, 0xfd, 0x05, 0x16, 0x16, 0x6f, 0xa4, 0x96, 0xfc, 0x2f, 0xbc, 0x84, 0xc7, 0x9d,
-	0xeb, 0x4b, 0x8b, 0x98, 0xe7, 0xd7, 0xe4, 0xc2, 0x6a, 0x75, 0x9a, 0x97, 0x2b, 0x0f, 0xf1, 0x97,
-	0xb0, 0xbc, 0x2a, 0x90, 0x4f, 0x9c, 0x0c, 0x7b, 0xd6, 0x9b, 0x66, 0xef, 0x0a, 0xfd, 0x07, 0xce,
-	0xfe, 0x04, 0xef, 0x1f, 0x4a, 0xe0, 0xfe, 0xa1, 0x04, 0xfe, 0x7d, 0x28, 0x81, 0x3f, 0x1e, 0x4b,
-	0x1b, 0xf7, 0x8f, 0xa5, 0x8d, 0x7f, 0x1e, 0x4b, 0x1b, 0xb0, 0xe4, 0xf2, 0x75, 0x2f, 0xaf, 0xb3,
-	0xf8, 0x25, 0x19, 0xde, 0xc4, 0xa9, 0x1b, 0xf0, 0xdb, 0x95, 0xb3, 0x2a, 0x76, 0xe3, 0xcf, 0xa5,
-	0xe7, 0xd1, 0xa1, 0xe0, 0x41, 0xd5, 0x65, 0x82, 0x06, 0xcc, 0xf6, 0xaa, 0x23, 0x5b, 0xd8, 0xd5,
-	0x25, 0xe1, 0x6b, 0x59, 0xf5, 0xb5, 0x43, 0xd9, 0xfc, 0xcb, 0x3e, 0xc8, 0xca, 0x54, 0xfd, 0xff,
-	0x00, 0x00, 0x00, 0xff, 0xff, 0x10, 0x24, 0x53, 0xc0, 0xff, 0x07, 0x00, 0x00,
+	// 864 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x96, 0x4d, 0x6f, 0xe2, 0x46,
+	0x18, 0xc7, 0x99, 0x84, 0x40, 0x32, 0x21, 0xec, 0x74, 0x9a, 0x4d, 0x5c, 0x52, 0x01, 0x4a, 0xdb,
+	0x2d, 0x4d, 0xb5, 0x46, 0x18, 0xaa, 0x56, 0xed, 0xa5, 0x90, 0x98, 0x08, 0x85, 0x25, 0xd1, 0x00,
+	0xdb, 0x97, 0x8b, 0x65, 0x60, 0xd6, 0x6b, 0x09, 0x66, 0x90, 0x3d, 0x46, 0xe1, 0xdc, 0x2f, 0x50,
+	0xf5, 0xbb, 0xf4, 0x13, 0xf4, 0x92, 0x63, 0x8e, 0x55, 0x0f, 0x51, 0x95, 0x7c, 0x90, 0x56, 0x1e,
+	0x3b, 0xec, 0x82, 0x6c, 0x72, 0xd9, 0x53, 0x9e, 0x79, 0x7e, 0xcf, 0xff, 0x79, 0x8b, 0x67, 0x04,
+	0x7c, 0xc1, 0xa7, 0x94, 0x09, 0x3a, 0xa6, 0x13, 0x2a, 0x9c, 0x79, 0x79, 0xea, 0x70, 0xc1, 0xcb,
+	0x63, 0x6e, 0xb9, 0xe5, 0x59, 0x45, 0xfe, 0x55, 0xa5, 0x0b, 0x1f, 0x2d, 0xc5, 0x05, 0x4e, 0x55,
+	0xf2, 0x59, 0x25, 0x57, 0xb3, 0x6c, 0xf1, 0xd6, 0x1b, 0xa8, 0x43, 0x3e, 0x29, 0x5b, 0xdc, 0xe2,
+	0x41, 0x9a, 0x81, 0xf7, 0xe6, 0xc7, 0x59, 0x45, 0xad, 0xaa, 0x15, 0xe9, 0x0c, 0x52, 0xfb, 0x56,
+	0xa0, 0xce, 0x9d, 0x44, 0x95, 0x1e, 0xf2, 0xc9, 0x84, 0x33, 0xbf, 0x78, 0x60, 0x85, 0xb1, 0x6a,
+	0x54, 0xac, 0x43, 0x5d, 0xee, 0x39, 0x43, 0xea, 0x47, 0x3f, 0xda, 0x41, 0xfc, 0xf1, 0x2d, 0x80,
+	0x19, 0x12, 0xba, 0xda, 0xdc, 0x72, 0xb1, 0x0e, 0xb7, 0x1f, 0x43, 0x14, 0x50, 0x04, 0xa5, 0x5d,
+	0xed, 0x2b, 0x35, 0x6a, 0xa4, 0x45, 0x9e, 0x59, 0x45, 0x7d, 0x4c, 0x40, 0x16, 0x52, 0x3c, 0x87,
+	0x9f, 0xda, 0xcc, 0x15, 0x8e, 0x37, 0xa1, 0x4c, 0x98, 0xc2, 0xe6, 0xcc, 0x18, 0xdb, 0x03, 0xc7,
+	0x74, 0xe6, 0x86, 0xbf, 0x0c, 0x65, 0xa3, 0xb8, 0x59, 0xda, 0xd5, 0xbe, 0x55, 0xd7, 0x6c, 0x4b,
+	0x6d, 0x2d, 0x27, 0x68, 0x07, 0x7a, 0xbf, 0x4b, 0x92, 0xb3, 0x63, 0xd9, 0xf1, 0x0d, 0x80, 0xb9,
+	0x78, 0x29, 0x66, 0xf0, 0x30, 0xa6, 0xb3, 0x70, 0xde, 0x6f, 0x22, 0x9b, 0x0a, 0xb7, 0x1c, 0xdb,
+	0x16, 0x39, 0x88, 0x6e, 0x09, 0x7f, 0x0f, 0x93, 0xef, 0x4d, 0xfc, 0x62, 0xed, 0xc4, 0x6d, 0x6e,
+	0x11, 0x3a, 0xe4, 0xce, 0x88, 0x48, 0xcd, 0xf1, 0x9f, 0x49, 0xb8, 0xb3, 0xf0, 0xe1, 0xcf, 0x61,
+	0x56, 0xd8, 0x13, 0x6a, 0x78, 0xcc, 0xbe, 0x36, 0x98, 0xc9, 0xb8, 0x6c, 0x38, 0x45, 0x32, 0xbe,
+	0xb7, 0xcf, 0xec, 0xeb, 0x8e, 0xc9, 0x38, 0xee, 0xc1, 0x67, 0x2e, 0x9d, 0x51, 0xc7, 0x16, 0x73,
+	0x83, 0x79, 0x93, 0x01, 0x75, 0x94, 0x8d, 0x22, 0x28, 0x65, 0xb5, 0xaf, 0xd7, 0x96, 0xee, 0x86,
+	0x9a, 0x8e, 0x94, 0x90, 0xac, 0xbb, 0x74, 0xc6, 0x9f, 0xc1, 0xbd, 0x45, 0x56, 0x41, 0xaf, 0x85,
+	0xb2, 0x59, 0x04, 0xa5, 0x1d, 0x92, 0x79, 0x74, 0xf6, 0xe8, 0xb5, 0xc0, 0x18, 0x26, 0x99, 0x39,
+	0xa1, 0x4a, 0x52, 0x32, 0x69, 0xe3, 0x1f, 0x60, 0x72, 0xc0, 0x47, 0x73, 0x65, 0x4b, 0xee, 0xf6,
+	0xcb, 0x27, 0x76, 0x5b, 0x67, 0xf3, 0xd7, 0xe6, 0xd8, 0xa3, 0x44, 0x8a, 0xf0, 0x39, 0x84, 0xa6,
+	0x10, 0x8e, 0x3d, 0xf0, 0x04, 0x75, 0x95, 0x94, 0xdc, 0xe0, 0x53, 0x29, 0x2e, 0x68, 0x98, 0xe2,
+	0x3d, 0x29, 0xfe, 0x0e, 0x2a, 0x23, 0x87, 0x4f, 0xa7, 0x74, 0x64, 0xbc, 0xf3, 0x1a, 0x43, 0xee,
+	0x31, 0xa1, 0xa4, 0x8b, 0xa0, 0xb4, 0x47, 0x0e, 0x42, 0x5e, 0x5f, 0xe0, 0x53, 0x9f, 0xe2, 0x7d,
+	0xb8, 0xf5, 0x66, 0x6c, 0x5a, 0xae, 0xb2, 0x5d, 0x04, 0xa5, 0x34, 0x09, 0x0e, 0xf8, 0x37, 0x00,
+	0xb7, 0x85, 0x63, 0x0e, 0xa9, 0x61, 0x8f, 0x94, 0x9d, 0x22, 0x28, 0x65, 0x1a, 0x6f, 0x6f, 0xee,
+	0x0a, 0x89, 0x7f, 0xee, 0x0a, 0x7d, 0x8b, 0xaf, 0x74, 0x68, 0xfb, 0xb7, 0x75, 0x3c, 0xa6, 0x43,
+	0xc1, 0x9d, 0xb2, 0xcd, 0x04, 0x75, 0x98, 0x39, 0x2e, 0x8f, 0x4c, 0x61, 0x96, 0x97, 0x02, 0x5f,
+	0xca, 0x51, 0x5e, 0x5a, 0x94, 0xbd, 0xbb, 0xdd, 0x6a, 0xcf, 0xaf, 0xd2, 0x3a, 0xbb, 0xbf, 0x2b,
+	0xa4, 0x03, 0x73, 0x44, 0xd2, 0x22, 0x30, 0xf0, 0x21, 0x4c, 0xbb, 0x53, 0x93, 0xf9, 0x3d, 0x40,
+	0xbf, 0x07, 0x92, 0xf2, 0x8f, 0xad, 0xd1, 0xc9, 0x5f, 0x5b, 0x30, 0xbb, 0xfc, 0x0f, 0xc5, 0x05,
+	0x78, 0xd4, 0xd5, 0x5f, 0xeb, 0xa4, 0xd5, 0xfb, 0xc5, 0xe8, 0xf4, 0x5f, 0x35, 0x74, 0x62, 0xf4,
+	0x3b, 0xdd, 0x2b, 0xfd, 0xb4, 0xd5, 0x6c, 0xe9, 0x67, 0x28, 0x81, 0x3f, 0x81, 0xcf, 0x57, 0x03,
+	0x7a, 0xa4, 0x7e, 0xaa, 0x23, 0x80, 0x73, 0xf0, 0x20, 0x12, 0x69, 0x68, 0x23, 0x96, 0x55, 0xd1,
+	0x66, 0x2c, 0xab, 0xa1, 0x64, 0x54, 0xb9, 0x33, 0xbd, 0xd1, 0x3f, 0x47, 0x5b, 0x51, 0x32, 0x89,
+	0x34, 0x94, 0x8a, 0x65, 0x55, 0x94, 0x8e, 0x65, 0x35, 0xb4, 0x8d, 0x15, 0xb8, 0xbf, 0xca, 0x5a,
+	0x9d, 0xe6, 0x25, 0xda, 0x89, 0x6a, 0xc4, 0x27, 0x1a, 0x82, 0x71, 0xa8, 0x8a, 0x76, 0xe3, 0x50,
+	0x0d, 0x65, 0xa2, 0x4a, 0xfd, 0x54, 0x27, 0x1d, 0xb4, 0x17, 0x25, 0xf2, 0x89, 0x86, 0xb2, 0x71,
+	0xa8, 0x8a, 0x9e, 0xc5, 0xa1, 0x1a, 0x42, 0x51, 0x48, 0x27, 0xe4, 0x92, 0xa0, 0x8f, 0xa2, 0x96,
+	0x21, 0x91, 0x86, 0x70, 0x2c, 0xab, 0xa2, 0x8f, 0x63, 0x59, 0x0d, 0xed, 0x47, 0x95, 0x6b, 0xd6,
+	0x7b, 0xf5, 0x36, 0x7a, 0x1e, 0x25, 0x93, 0x48, 0x43, 0x07, 0xb1, 0xac, 0x8a, 0x0e, 0x63, 0x59,
+	0x0d, 0x29, 0x27, 0x3f, 0xc3, 0xec, 0xe2, 0xf1, 0x6b, 0xca, 0x6b, 0x57, 0x80, 0x47, 0xed, 0xcb,
+	0x73, 0x83, 0xe8, 0xa7, 0x97, 0xe4, 0xcc, 0x68, 0xb6, 0xeb, 0xe7, 0x2b, 0x1f, 0xf1, 0x17, 0xb0,
+	0xb8, 0x1a, 0x20, 0xbf, 0x38, 0x69, 0x76, 0x8d, 0x57, 0xf5, 0xee, 0x05, 0xfa, 0x0f, 0x34, 0xfe,
+	0x00, 0x37, 0xf7, 0x79, 0x70, 0x7b, 0x9f, 0x07, 0xff, 0xde, 0xe7, 0xc1, 0xef, 0x0f, 0xf9, 0xc4,
+	0xed, 0x43, 0x3e, 0xf1, 0xf7, 0x43, 0x3e, 0x01, 0xf3, 0x36, 0x5f, 0xf7, 0x4e, 0x36, 0xfc, 0xf7,
+	0xd8, 0xbd, 0xf2, 0x5d, 0x57, 0xe0, 0xd7, 0x8b, 0x0f, 0x71, 0xd7, 0xc3, 0x1f, 0x11, 0x83, 0x94,
+	0x74, 0x55, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0x00, 0xc2, 0xc4, 0xbb, 0x6a, 0x08, 0x00, 0x00,
 }
 
 func (m *ResourceLogs) Marshal() (dAtA []byte, err error) {
@@ -600,13 +596,16 @@ func (m *LogRecord) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x52
 	}
-	if len(m.TraceId) > 0 {
-		i -= len(m.TraceId)
-		copy(dAtA[i:], m.TraceId)
-		i = encodeVarintLogs(dAtA, i, uint64(len(m.TraceId)))
-		i--
-		dAtA[i] = 0x4a
+	{
+		size := m.TraceId.Size()
+		i -= size
+		if _, err := m.TraceId.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintLogs(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0x4a
 	if m.Flags != 0 {
 		i -= 4
 		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(m.Flags))
@@ -757,10 +756,8 @@ func (m *LogRecord) Size() (n int) {
 	if m.Flags != 0 {
 		n += 5
 	}
-	l = len(m.TraceId)
-	if l > 0 {
-		n += 1 + l + sovLogs(uint64(l))
-	}
+	l = m.TraceId.Size()
+	n += 1 + l + sovLogs(uint64(l))
 	l = len(m.SpanId)
 	if l > 0 {
 		n += 1 + l + sovLogs(uint64(l))
@@ -1270,9 +1267,8 @@ func (m *LogRecord) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
-			if m.TraceId == nil {
-				m.TraceId = []byte{}
+			if err := m.TraceId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 10:
diff --git a/internal/data/opentelemetry-proto-gen/metrics/v1/metrics.pb.go b/internal/data/opentelemetry-proto-gen/metrics/v1/metrics.pb.go
index d5812baf022..692c7d74700 100644
--- a/internal/data/opentelemetry-proto-gen/metrics/v1/metrics.pb.go
+++ b/internal/data/opentelemetry-proto-gen/metrics/v1/metrics.pb.go
@@ -10,8 +10,10 @@ import (
 	math "math"
 	math_bits "math/bits"
 
+	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 
+	go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v11 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/resource/v1"
 )
@@ -1338,7 +1340,7 @@ type IntExemplar struct {
 	// (Optional) Trace ID of the exemplar trace.
 	// trace_id may be missing if the measurement is not recorded inside a trace
 	// or if the trace is not sampled.
-	TraceId []byte `protobuf:"bytes,5,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	TraceId go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1.TraceID `protobuf:"bytes,5,opt,name=trace_id,json=traceId,proto3,customtype=go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1.TraceID" json:"trace_id"`
 }
 
 func (m *IntExemplar) Reset()         { *m = IntExemplar{} }
@@ -1402,13 +1404,6 @@ func (m *IntExemplar) GetSpanId() []byte {
 	return nil
 }
 
-func (m *IntExemplar) GetTraceId() []byte {
-	if m != nil {
-		return m.TraceId
-	}
-	return nil
-}
-
 // A representation of an exemplar, which is a sample input double measurement.
 // Exemplars also hold information about the environment when the measurement
 // was recorded, for example the span and trace ID of the active span when the
@@ -1432,7 +1427,7 @@ type DoubleExemplar struct {
 	// (Optional) Trace ID of the exemplar trace.
 	// trace_id may be missing if the measurement is not recorded inside a trace
 	// or if the trace is not sampled.
-	TraceId []byte `protobuf:"bytes,5,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	TraceId go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1.TraceID `protobuf:"bytes,5,opt,name=trace_id,json=traceId,proto3,customtype=go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1.TraceID" json:"trace_id"`
 }
 
 func (m *DoubleExemplar) Reset()         { *m = DoubleExemplar{} }
@@ -1496,13 +1491,6 @@ func (m *DoubleExemplar) GetSpanId() []byte {
 	return nil
 }
 
-func (m *DoubleExemplar) GetTraceId() []byte {
-	if m != nil {
-		return m.TraceId
-	}
-	return nil
-}
-
 func init() {
 	proto.RegisterEnum("opentelemetry.proto.metrics.v1.AggregationTemporality", AggregationTemporality_name, AggregationTemporality_value)
 	proto.RegisterType((*ResourceMetrics)(nil), "opentelemetry.proto.metrics.v1.ResourceMetrics")
@@ -1527,76 +1515,80 @@ func init() {
 }
 
 var fileDescriptor_3c3112f9fa006917 = []byte{
-	// 1099 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0x41, 0x4f, 0xe3, 0xc6,
-	0x17, 0xcf, 0x24, 0xe0, 0x24, 0x2f, 0x59, 0xc8, 0x7f, 0xb4, 0x7f, 0x70, 0x57, 0x22, 0x85, 0x6c,
-	0xc5, 0xd2, 0xdd, 0x25, 0x11, 0x54, 0x5b, 0xf5, 0x52, 0xa9, 0x01, 0x52, 0x48, 0x1b, 0xd8, 0xc8,
-	0x04, 0x24, 0xaa, 0x4a, 0x96, 0x63, 0x4f, 0xd3, 0x51, 0xed, 0x99, 0xc8, 0x1e, 0x23, 0xf8, 0x00,
-	0xbd, 0xb5, 0x52, 0xa5, 0x1e, 0xfb, 0x41, 0xfa, 0x15, 0x7a, 0xdc, 0x1e, 0xaa, 0xee, 0xa5, 0xd2,
-	0x0a, 0x8e, 0x3d, 0xf5, 0xd2, 0x53, 0x0f, 0x95, 0xc7, 0x36, 0x24, 0x60, 0x48, 0x56, 0x6c, 0xa5,
-	0xec, 0xed, 0xcd, 0x9b, 0xf7, 0x7e, 0xfe, 0xbd, 0xdf, 0x7b, 0x2f, 0x36, 0xc0, 0x53, 0xde, 0x27,
-	0x4c, 0x10, 0x9b, 0x38, 0x44, 0xb8, 0xa7, 0xb5, 0xbe, 0xcb, 0x05, 0xaf, 0x05, 0x36, 0x35, 0xbd,
-	0xda, 0xf1, 0x5a, 0x6c, 0x56, 0xe5, 0x05, 0x2e, 0x0f, 0x45, 0x87, 0xce, 0x6a, 0x1c, 0x72, 0xbc,
-	0xf6, 0xe0, 0x71, 0x12, 0x9a, 0xc9, 0x1d, 0x87, 0xb3, 0x00, 0x2c, 0xb4, 0xc2, 0xb4, 0x07, 0xd5,
-	0xa4, 0x58, 0x97, 0x78, 0xdc, 0x77, 0x4d, 0x12, 0x44, 0xc7, 0x76, 0x18, 0x5f, 0x79, 0x85, 0x60,
-	0x56, 0x8b, 0x5c, 0xbb, 0xe1, 0x23, 0x71, 0x03, 0x72, 0x71, 0x94, 0x8a, 0x16, 0xd1, 0x4a, 0x61,
-	0xfd, 0xfd, 0x6a, 0x12, 0xc5, 0x0b, 0xa8, 0xe3, 0xb5, 0x6a, 0x8c, 0xa1, 0x5d, 0xa4, 0xe2, 0x6f,
-	0x11, 0xbc, 0x4b, 0x99, 0x27, 0x5c, 0xdf, 0x21, 0x4c, 0x18, 0x82, 0x72, 0xa6, 0xdb, 0xb4, 0xeb,
-	0x1a, 0xee, 0xa9, 0x1e, 0x55, 0xa7, 0xa6, 0x17, 0x33, 0x2b, 0x85, 0xf5, 0x8f, 0xab, 0xb7, 0x2b,
-	0x50, 0x6d, 0x0e, 0xc3, 0xb4, 0x42, 0x94, 0x88, 0xaf, 0xb6, 0x40, 0x6f, 0xbb, 0xae, 0xfc, 0x8a,
-	0x60, 0xe1, 0x56, 0x00, 0xcc, 0x60, 0xfe, 0x06, 0xa2, 0x51, 0xfd, 0xcf, 0x12, 0x09, 0x46, 0xc2,
-	0xdf, 0xc8, 0x4f, 0x9b, 0x4b, 0x26, 0x86, 0x3f, 0x81, 0xec, 0xb0, 0x00, 0xcb, 0xa3, 0x04, 0x08,
-	0x99, 0x6a, 0x71, 0x5a, 0xe5, 0xe7, 0x29, 0x50, 0x42, 0x1f, 0xc6, 0x30, 0xc5, 0x0c, 0x27, 0xec,
-	0x54, 0x5e, 0x93, 0x36, 0x5e, 0x84, 0x82, 0x45, 0x3c, 0xd3, 0xa5, 0xfd, 0xe0, 0xb1, 0x6a, 0x5a,
-	0x5e, 0x0d, 0xba, 0x82, 0x2c, 0x9f, 0x51, 0xa1, 0x66, 0xc2, 0xac, 0xc0, 0xc6, 0xdb, 0x90, 0xa7,
-	0x4c, 0xe8, 0x3d, 0xc3, 0xef, 0x11, 0x75, 0x4a, 0x16, 0xbe, 0x32, 0xba, 0x33, 0x62, 0x3b, 0x88,
-	0xdf, 0x49, 0x69, 0x39, 0x1a, 0xd9, 0xb8, 0x0d, 0x45, 0x8b, 0xfb, 0x5d, 0x9b, 0x44, 0x58, 0xd3,
-	0x12, 0xeb, 0xc9, 0x28, 0xac, 0x2d, 0x99, 0x13, 0xc3, 0x15, 0xac, 0xcb, 0x23, 0xae, 0x43, 0x36,
-	0xa0, 0xe6, 0xf9, 0x8e, 0xaa, 0x48, 0xb0, 0xe5, 0x31, 0x88, 0xed, 0xfb, 0xce, 0x4e, 0x4a, 0x53,
-	0xa8, 0xb4, 0xf0, 0x67, 0x00, 0x11, 0xa9, 0x00, 0x25, 0x7b, 0xcb, 0x5c, 0x5f, 0xa3, 0x14, 0x02,
-	0xe5, 0xad, 0xf8, 0x80, 0xf7, 0xe1, 0x5e, 0x40, 0xe7, 0x6b, 0xea, 0x09, 0xde, 0x73, 0x0d, 0x47,
-	0xcd, 0x49, 0xb8, 0xa7, 0x63, 0x90, 0xda, 0x89, 0x73, 0x76, 0x52, 0x5a, 0x91, 0x0e, 0x9c, 0xf1,
-	0x97, 0x50, 0x8a, 0x08, 0x5e, 0xe2, 0xe6, 0x25, 0x6e, 0x6d, 0x3c, 0x9a, 0x83, 0xd0, 0xb3, 0xd6,
-	0xb0, 0x6b, 0x43, 0x81, 0x29, 0xcb, 0x10, 0x46, 0xe5, 0x08, 0x72, 0x71, 0xcf, 0xf0, 0x2e, 0x14,
-	0x02, 0x9f, 0xde, 0xe7, 0x94, 0x09, 0x4f, 0x45, 0x72, 0x16, 0xc7, 0x29, 0x62, 0xcb, 0x10, 0x46,
-	0x3b, 0x48, 0xd2, 0xc0, 0x8a, 0x4d, 0xaf, 0xa2, 0x43, 0x61, 0xa0, 0x85, 0xb8, 0x9d, 0x84, 0x3e,
-	0x66, 0x29, 0xc9, 0x0f, 0xf8, 0x13, 0x81, 0x12, 0xf6, 0xf5, 0x0d, 0x53, 0xc7, 0x1c, 0xe6, 0x8d,
-	0x5e, 0xcf, 0x25, 0xbd, 0x70, 0xfb, 0x05, 0x71, 0xfa, 0xdc, 0x35, 0x6c, 0x2a, 0x4e, 0xe5, 0xf2,
-	0xcc, 0xac, 0x7f, 0x38, 0x0a, 0xba, 0x7e, 0x99, 0xde, 0xb9, 0xcc, 0xd6, 0xe6, 0x8c, 0x44, 0x3f,
-	0x5e, 0x82, 0x22, 0xf5, 0x74, 0x87, 0x33, 0x2e, 0x38, 0xa3, 0xa6, 0xdc, 0xc3, 0x9c, 0x56, 0xa0,
-	0xde, 0x6e, 0xec, 0xaa, 0xfc, 0x85, 0x20, 0x7f, 0x31, 0x7f, 0x6f, 0x5e, 0xcd, 0x89, 0xac, 0xf9,
-	0x77, 0x04, 0xc5, 0xc1, 0x25, 0xc1, 0x87, 0x49, 0x65, 0x3f, 0x7b, 0x9d, 0x3d, 0x9b, 0x8c, 0xe2,
-	0x2b, 0x7f, 0x20, 0x98, 0xbd, 0xb2, 0xa6, 0xf8, 0x28, 0xa9, 0xb8, 0x8f, 0x5e, 0x73, 0xd9, 0x27,
-	0xa4, 0xbe, 0xef, 0xd3, 0xb2, 0x73, 0x17, 0x6c, 0x70, 0x03, 0x14, 0xdb, 0xe8, 0x12, 0x3b, 0xae,
-	0x6b, 0x75, 0xc4, 0x3b, 0x74, 0x5f, 0xb8, 0x94, 0xf5, 0x3e, 0x27, 0xa7, 0x87, 0x86, 0xed, 0x13,
-	0x2d, 0x4a, 0xc6, 0x35, 0xb8, 0xef, 0x09, 0xc3, 0x15, 0xba, 0xa0, 0x0e, 0xd1, 0x7d, 0x46, 0x4f,
-	0x74, 0x66, 0x30, 0x2e, 0xab, 0x50, 0xb4, 0xff, 0xc9, 0xbb, 0x0e, 0x75, 0xc8, 0x01, 0xa3, 0x27,
-	0x7b, 0x06, 0xe3, 0xf8, 0x3d, 0x98, 0xb9, 0x12, 0x9a, 0x91, 0xa1, 0x45, 0x31, 0x18, 0x75, 0x1f,
-	0xa6, 0x8f, 0x83, 0xe7, 0xc8, 0xf7, 0x5c, 0x49, 0x0b, 0x0f, 0xb8, 0x09, 0x79, 0x72, 0x42, 0x9c,
-	0xbe, 0x6d, 0xb8, 0x9e, 0x3a, 0x2d, 0x69, 0x3f, 0x19, 0x63, 0xd6, 0x1a, 0x51, 0x8e, 0x76, 0x99,
-	0x5d, 0xf9, 0x31, 0x1d, 0xf7, 0xfb, 0xad, 0x94, 0x04, 0xc5, 0x92, 0xb4, 0xae, 0x4b, 0x52, 0x1d,
-	0x6f, 0x42, 0x93, 0x54, 0xf9, 0x3b, 0x0d, 0xff, 0x4f, 0x5c, 0xce, 0xc9, 0xd7, 0xc6, 0xe4, 0x3e,
-	0x13, 0x52, 0x1b, 0x45, 0x0b, 0x0f, 0xb8, 0x04, 0x99, 0xe0, 0x5b, 0x62, 0x5a, 0x8e, 0x50, 0x60,
-	0xe2, 0x87, 0x70, 0xaf, 0xeb, 0x9b, 0xdf, 0x10, 0xa1, 0xcb, 0x08, 0x4f, 0x55, 0x16, 0x33, 0x01,
-	0x58, 0xe8, 0xdc, 0x94, 0x3e, 0xfc, 0x08, 0x66, 0xc9, 0x49, 0xdf, 0xa6, 0x26, 0x15, 0x7a, 0x97,
-	0xfb, 0xcc, 0xf2, 0xd4, 0xec, 0x62, 0x66, 0x05, 0x69, 0x33, 0xb1, 0x7b, 0x43, 0x7a, 0x87, 0xc7,
-	0x31, 0x77, 0xa7, 0x71, 0xfc, 0x27, 0x0d, 0xea, 0x4d, 0x3f, 0x1c, 0x6f, 0xbb, 0xf6, 0xe8, 0xbf,
-	0xd0, 0xbe, 0x75, 0x5d, 0xfb, 0x3b, 0xcc, 0xfd, 0x6f, 0x08, 0x0a, 0x03, 0x9d, 0xc1, 0x87, 0x30,
-	0xfb, 0x15, 0xb5, 0x05, 0x71, 0x89, 0xa5, 0xdf, 0x45, 0xfa, 0x99, 0x18, 0xa5, 0x15, 0xb6, 0xe0,
-	0xba, 0xa2, 0xe9, 0xdb, 0x36, 0x3d, 0x33, 0xf8, 0xe3, 0x37, 0x0f, 0x59, 0xaf, 0x6f, 0x30, 0x9d,
-	0x5a, 0x52, 0xe9, 0xa2, 0xa6, 0x04, 0xc7, 0xa6, 0x85, 0xdf, 0x81, 0x9c, 0x70, 0x0d, 0x93, 0x04,
-	0x37, 0xd3, 0xf2, 0x26, 0x2b, 0xcf, 0x4d, 0xab, 0xf2, 0x12, 0xc1, 0xcc, 0x70, 0xd5, 0x93, 0x54,
-	0x1a, 0xba, 0x43, 0x69, 0x8f, 0xbf, 0x43, 0x30, 0x97, 0xfc, 0x0e, 0xc4, 0x8f, 0xe0, 0x61, 0x7d,
-	0x7b, 0x5b, 0x6b, 0x6c, 0xd7, 0x3b, 0xcd, 0xe7, 0x7b, 0x7a, 0xa7, 0xb1, 0xdb, 0x7e, 0xae, 0xd5,
-	0x5b, 0xcd, 0xce, 0x91, 0x7e, 0xb0, 0xb7, 0xdf, 0x6e, 0x6c, 0x36, 0x3f, 0x6d, 0x36, 0xb6, 0x4a,
-	0x29, 0xbc, 0x04, 0x0b, 0x37, 0x05, 0x6e, 0x35, 0x5a, 0x9d, 0x7a, 0x09, 0xe1, 0x65, 0xa8, 0xdc,
-	0x14, 0xb2, 0x79, 0xb0, 0x7b, 0xd0, 0xaa, 0x77, 0x9a, 0x87, 0x8d, 0x52, 0x7a, 0xe3, 0x27, 0xf4,
-	0xcb, 0x59, 0x19, 0xbd, 0x38, 0x2b, 0xa3, 0x57, 0x67, 0x65, 0xf4, 0xc3, 0x79, 0x39, 0xf5, 0xe2,
-	0xbc, 0x9c, 0x7a, 0x79, 0x5e, 0x4e, 0xc1, 0x12, 0xe5, 0x23, 0x26, 0x73, 0xa3, 0x18, 0xfd, 0xa9,
-	0xdb, 0x0e, 0x2e, 0xda, 0xe8, 0x8b, 0xbd, 0xde, 0xd5, 0x14, 0xca, 0x6b, 0x26, 0xb7, 0x6d, 0x62,
-	0x0a, 0xee, 0xd6, 0x28, 0x13, 0xc4, 0x65, 0x86, 0x5d, 0x0b, 0xbe, 0x28, 0x6a, 0x43, 0x81, 0xab,
-	0x12, 0x7b, 0xb5, 0x47, 0xd8, 0xc0, 0x3f, 0x34, 0xba, 0x8a, 0xf4, 0x7e, 0xf0, 0x6f, 0x00, 0x00,
-	0x00, 0xff, 0xff, 0x5b, 0xe2, 0x24, 0x7c, 0xf9, 0x10, 0x00, 0x00,
+	// 1164 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x58, 0xcd, 0x6f, 0xdb, 0xc6,
+	0x13, 0x15, 0x25, 0x5b, 0x1f, 0x23, 0xc5, 0xd6, 0x6f, 0x91, 0x5f, 0x42, 0x04, 0x88, 0xec, 0x28,
+	0x45, 0xe2, 0xe6, 0x83, 0x82, 0x93, 0xa6, 0xe8, 0xa5, 0x40, 0xe4, 0x58, 0xb5, 0xd5, 0xca, 0x8e,
+	0x40, 0xcb, 0x06, 0x52, 0x14, 0x20, 0x28, 0x71, 0xc3, 0x2c, 0x4a, 0xee, 0x0a, 0xe4, 0xd2, 0xb0,
+	0xcf, 0x45, 0x6f, 0x2d, 0x50, 0xa0, 0xc7, 0xfe, 0x21, 0xbd, 0x16, 0xe8, 0x25, 0xc7, 0xf4, 0xd4,
+	0xa2, 0x40, 0x8d, 0xc0, 0x3e, 0xf6, 0xd4, 0x4b, 0x4f, 0x3d, 0x14, 0xbb, 0x24, 0x2d, 0xc9, 0xa6,
+	0x2d, 0x05, 0x76, 0x01, 0xfb, 0x36, 0x3b, 0x3b, 0xf3, 0xf8, 0xe6, 0xcd, 0x8c, 0x68, 0x1a, 0x1e,
+	0xb0, 0x3e, 0xa6, 0x1c, 0x3b, 0xd8, 0xc5, 0xdc, 0xdb, 0xad, 0xf5, 0x3d, 0xc6, 0x59, 0x4d, 0xd8,
+	0xa4, 0xe7, 0xd7, 0xb6, 0x17, 0x63, 0x53, 0x93, 0x17, 0xa8, 0x32, 0x12, 0x1d, 0x3a, 0xb5, 0x38,
+	0x64, 0x7b, 0xf1, 0xc6, 0x07, 0x36, 0xe1, 0xaf, 0x82, 0xae, 0xd6, 0x63, 0x6e, 0xcd, 0x66, 0x36,
+	0x0b, 0xf1, 0xba, 0xc1, 0xcb, 0xa7, 0xdb, 0x8b, 0xda, 0x63, 0x6d, 0x51, 0x3a, 0xc3, 0x67, 0x08,
+	0x2b, 0x04, 0xb8, 0x71, 0x2f, 0x89, 0x43, 0x8f, 0xb9, 0x2e, 0xa3, 0x82, 0x42, 0x68, 0x45, 0xb1,
+	0x5a, 0x52, 0xac, 0x87, 0x7d, 0x16, 0x78, 0x3d, 0x2c, 0xa2, 0x63, 0x3b, 0x8c, 0xaf, 0xbe, 0x55,
+	0x60, 0x56, 0x8f, 0x5c, 0x6b, 0x21, 0x51, 0xd4, 0x80, 0x7c, 0x1c, 0xa5, 0x2a, 0xf3, 0xca, 0x42,
+	0xf1, 0xd1, 0xfb, 0x5a, 0x52, 0x61, 0x87, 0x50, 0xdb, 0x8b, 0x5a, 0x8c, 0xa1, 0x1f, 0xa6, 0xa2,
+	0xaf, 0x15, 0x98, 0x23, 0xd4, 0xe7, 0x5e, 0xe0, 0x62, 0xca, 0x4d, 0x4e, 0x18, 0x35, 0x1c, 0xd2,
+	0xf5, 0x4c, 0x6f, 0xd7, 0x88, 0x34, 0x51, 0xd3, 0xf3, 0x99, 0x85, 0xe2, 0xa3, 0x8f, 0xb5, 0xd3,
+	0x75, 0xd3, 0x9a, 0xa3, 0x30, 0xad, 0x10, 0x25, 0xe2, 0xab, 0xdf, 0x24, 0xa7, 0x5d, 0x57, 0x7f,
+	0x51, 0xe0, 0xe6, 0xa9, 0x00, 0x88, 0xc2, 0xf5, 0x13, 0x88, 0x46, 0xf5, 0x3f, 0x49, 0x24, 0x18,
+	0x09, 0x7f, 0x22, 0x3f, 0xfd, 0x5a, 0x32, 0x31, 0xf4, 0x14, 0x72, 0xa3, 0x02, 0xdc, 0x19, 0x27,
+	0x40, 0xc8, 0x54, 0x8f, 0xd3, 0xaa, 0x3f, 0x4e, 0x41, 0x36, 0xf4, 0x21, 0x04, 0x53, 0xd4, 0x74,
+	0xc3, 0x4e, 0x15, 0x74, 0x69, 0xa3, 0x79, 0x28, 0x5a, 0xd8, 0xef, 0x79, 0xa4, 0x2f, 0x1e, 0xab,
+	0xa6, 0xe5, 0xd5, 0xb0, 0x4b, 0x64, 0x05, 0x94, 0x70, 0x35, 0x13, 0x66, 0x09, 0x1b, 0xad, 0x40,
+	0x81, 0x50, 0x6e, 0xd8, 0x66, 0x60, 0x63, 0x75, 0x4a, 0x16, 0xbe, 0x30, 0xbe, 0x33, 0x7c, 0x45,
+	0xc4, 0xaf, 0xa6, 0xf4, 0x3c, 0x89, 0x6c, 0xd4, 0x86, 0x92, 0xc5, 0x82, 0xae, 0x83, 0x23, 0xac,
+	0x69, 0x89, 0x75, 0x7f, 0x1c, 0xd6, 0xb2, 0xcc, 0x89, 0xe1, 0x8a, 0xd6, 0xe0, 0x88, 0xea, 0x90,
+	0x13, 0xd4, 0xfc, 0xc0, 0x55, 0xb3, 0x12, 0xec, 0xce, 0x04, 0xc4, 0x36, 0x02, 0x77, 0x35, 0xa5,
+	0x67, 0x89, 0xb4, 0xd0, 0xa7, 0x00, 0x11, 0x29, 0x81, 0x92, 0x3b, 0x65, 0xae, 0x8f, 0x51, 0x0a,
+	0x81, 0x0a, 0x56, 0x7c, 0x40, 0x1b, 0x70, 0x45, 0xd0, 0x79, 0x45, 0x7c, 0xce, 0x6c, 0xcf, 0x74,
+	0xd5, 0xbc, 0x84, 0x7b, 0x30, 0x01, 0xa9, 0xd5, 0x38, 0x67, 0x35, 0xa5, 0x97, 0xc8, 0xd0, 0x19,
+	0x7d, 0x01, 0xe5, 0x88, 0xe0, 0x00, 0xb7, 0x20, 0x71, 0x6b, 0x93, 0xd1, 0x1c, 0x86, 0x9e, 0xb5,
+	0x46, 0x5d, 0x4b, 0x59, 0x98, 0xb2, 0x4c, 0x6e, 0x56, 0x5f, 0x40, 0x3e, 0xee, 0x19, 0x5a, 0x83,
+	0xa2, 0xf0, 0x19, 0x7d, 0x46, 0x28, 0xf7, 0x55, 0x45, 0xce, 0xe2, 0x24, 0x45, 0x2c, 0x9b, 0xdc,
+	0x6c, 0x8b, 0x24, 0x1d, 0xac, 0xd8, 0xf4, 0xab, 0x06, 0x14, 0x87, 0x5a, 0x88, 0xda, 0x49, 0xe8,
+	0x13, 0x96, 0x92, 0xfc, 0x80, 0x3f, 0x15, 0xc8, 0x86, 0x7d, 0x3d, 0x67, 0xea, 0x88, 0xc1, 0x75,
+	0xd3, 0xb6, 0x3d, 0x6c, 0x87, 0xdb, 0xcf, 0xb1, 0xdb, 0x67, 0x9e, 0xe9, 0x10, 0xbe, 0x2b, 0x97,
+	0x67, 0xe6, 0xd1, 0x87, 0xe3, 0xa0, 0xeb, 0x83, 0xf4, 0xce, 0x20, 0x5b, 0xbf, 0x66, 0x26, 0xfa,
+	0xd1, 0x2d, 0x28, 0x11, 0xdf, 0x70, 0x19, 0x65, 0x9c, 0x51, 0xd2, 0x93, 0x7b, 0x98, 0xd7, 0x8b,
+	0xc4, 0x5f, 0x8b, 0x5d, 0xd5, 0xbf, 0x14, 0x28, 0x1c, 0xce, 0xdf, 0xf9, 0xab, 0x79, 0x21, 0x6b,
+	0xfe, 0x55, 0x81, 0xd2, 0xf0, 0x92, 0xa0, 0xad, 0xa4, 0xb2, 0x9f, 0xbc, 0xcb, 0x9e, 0x5d, 0x8c,
+	0xe2, 0xab, 0x7f, 0x28, 0x30, 0x7b, 0x64, 0x4d, 0xd1, 0x8b, 0xa4, 0xe2, 0x3e, 0x7a, 0xc7, 0x65,
+	0xbf, 0x20, 0xf5, 0x7d, 0x9b, 0x96, 0x9d, 0x3b, 0x64, 0x83, 0x1a, 0x90, 0x75, 0xcc, 0x2e, 0x76,
+	0xe2, 0xba, 0x1e, 0x8e, 0x79, 0x87, 0x6e, 0x70, 0x8f, 0x50, 0xfb, 0x33, 0xbc, 0xbb, 0x65, 0x3a,
+	0x01, 0xd6, 0xa3, 0x64, 0x54, 0x83, 0xab, 0x3e, 0x37, 0x3d, 0x6e, 0x70, 0xe2, 0x62, 0x23, 0xa0,
+	0x64, 0xc7, 0xa0, 0x26, 0x65, 0xb2, 0x8a, 0xac, 0xfe, 0x3f, 0x79, 0xd7, 0x21, 0x2e, 0xde, 0xa4,
+	0x64, 0x67, 0xdd, 0xa4, 0x0c, 0xbd, 0x07, 0x33, 0x47, 0x42, 0x33, 0x32, 0xb4, 0xc4, 0x87, 0xa3,
+	0xae, 0xc2, 0xf4, 0xb6, 0x78, 0x8e, 0x7c, 0xcf, 0x95, 0xf5, 0xf0, 0x80, 0x9a, 0x50, 0xc0, 0x3b,
+	0xd8, 0xed, 0x3b, 0xa6, 0xe7, 0xab, 0xd3, 0x92, 0xf6, 0xfd, 0x09, 0x66, 0xad, 0x11, 0xe5, 0xe8,
+	0x83, 0xec, 0xea, 0xf7, 0xe9, 0xb8, 0xdf, 0x97, 0x52, 0x12, 0x25, 0x96, 0xa4, 0x75, 0x5c, 0x12,
+	0x6d, 0xb2, 0x09, 0x4d, 0x52, 0xe5, 0xef, 0x34, 0xfc, 0x3f, 0x71, 0x39, 0x2f, 0xbe, 0x36, 0x3d,
+	0x16, 0x50, 0x2e, 0xb5, 0xc9, 0xea, 0xe1, 0x01, 0x95, 0x21, 0x23, 0xfe, 0x96, 0x98, 0x96, 0x23,
+	0x24, 0x4c, 0x74, 0x1b, 0xae, 0x74, 0x83, 0xde, 0x97, 0x98, 0x1b, 0x32, 0xc2, 0x57, 0xb3, 0xf3,
+	0x19, 0x01, 0x16, 0x3a, 0x9f, 0x49, 0x1f, 0xba, 0x0b, 0xb3, 0x78, 0xa7, 0xef, 0x90, 0x1e, 0xe1,
+	0x46, 0x97, 0x05, 0xd4, 0xf2, 0xd5, 0xdc, 0x7c, 0x66, 0x41, 0xd1, 0x67, 0x62, 0xf7, 0x92, 0xf4,
+	0x8e, 0x8e, 0x63, 0xfe, 0x4c, 0xe3, 0xf8, 0x4f, 0x1a, 0xd4, 0x93, 0x7e, 0x38, 0x2e, 0xbb, 0xf6,
+	0xca, 0x7f, 0xa1, 0x7d, 0xeb, 0xb8, 0xf6, 0x67, 0x98, 0xfb, 0x9f, 0xd2, 0x50, 0x1c, 0xea, 0x0c,
+	0xda, 0x82, 0xd9, 0x97, 0xc4, 0xe1, 0xd8, 0xc3, 0x96, 0x71, 0x16, 0xe9, 0x67, 0x62, 0x94, 0x56,
+	0xd8, 0x82, 0xe3, 0x8a, 0xa6, 0x4f, 0xdb, 0xf4, 0xcc, 0xf0, 0x8f, 0xdf, 0x75, 0xc8, 0xf9, 0x7d,
+	0x93, 0x1a, 0xc4, 0x92, 0x4a, 0x97, 0xf4, 0xac, 0x38, 0x36, 0x2d, 0xf4, 0x95, 0x02, 0x79, 0xee,
+	0x99, 0x3d, 0x2c, 0xae, 0x84, 0xe0, 0xa5, 0xa5, 0x57, 0xaf, 0xf7, 0xe6, 0x52, 0xbf, 0xef, 0xcd,
+	0x6d, 0xda, 0xec, 0x08, 0x61, 0x22, 0x3e, 0x4d, 0x1d, 0x07, 0xf7, 0x38, 0xf3, 0x6a, 0x84, 0x72,
+	0xec, 0x51, 0xd3, 0xa9, 0x89, 0x37, 0x53, 0x6d, 0x24, 0xf0, 0xa1, 0xac, 0xec, 0xa1, 0x8d, 0xe9,
+	0xe0, 0x53, 0x56, 0xeb, 0x88, 0xa7, 0x34, 0x97, 0xf7, 0xf7, 0xe6, 0x72, 0xa1, 0x69, 0xe9, 0x39,
+	0x1e, 0x1a, 0xd5, 0x9f, 0xd3, 0x30, 0x33, 0x2a, 0xf0, 0x45, 0x52, 0x51, 0xb9, 0x1c, 0x2a, 0xde,
+	0xfb, 0x46, 0x81, 0x6b, 0xc9, 0x6f, 0x76, 0x74, 0x17, 0x6e, 0xd7, 0x57, 0x56, 0xf4, 0xc6, 0x4a,
+	0xbd, 0xd3, 0x7c, 0xbe, 0x6e, 0x74, 0x1a, 0x6b, 0xed, 0xe7, 0x7a, 0xbd, 0xd5, 0xec, 0xbc, 0x30,
+	0x36, 0xd7, 0x37, 0xda, 0x8d, 0x67, 0xcd, 0x4f, 0x9a, 0x8d, 0xe5, 0x72, 0x0a, 0xdd, 0x82, 0x9b,
+	0x27, 0x05, 0x2e, 0x37, 0x5a, 0x9d, 0x7a, 0x59, 0x41, 0x77, 0xa0, 0x7a, 0x52, 0xc8, 0xb3, 0xcd,
+	0xb5, 0xcd, 0x56, 0xbd, 0xd3, 0xdc, 0x6a, 0x94, 0xd3, 0x4b, 0x3f, 0x28, 0xaf, 0xf7, 0x2b, 0xca,
+	0x9b, 0xfd, 0x8a, 0xf2, 0x76, 0xbf, 0xa2, 0x7c, 0x77, 0x50, 0x49, 0xbd, 0x39, 0xa8, 0xa4, 0x7e,
+	0x3b, 0xa8, 0xa4, 0xe0, 0x16, 0x61, 0x63, 0xf6, 0x6d, 0xa9, 0x14, 0x7d, 0xc0, 0xb7, 0xc5, 0x45,
+	0x5b, 0xf9, 0x7c, 0xfd, 0x3c, 0x74, 0x1c, 0xfc, 0x73, 0xa7, 0x9b, 0x95, 0xde, 0xc7, 0xff, 0x06,
+	0x00, 0x00, 0xff, 0xff, 0x70, 0x04, 0x32, 0x6e, 0x05, 0x12, 0x00, 0x00,
 }
 
 func (m *ResourceMetrics) Marshal() (dAtA []byte, err error) {
@@ -2484,13 +2476,16 @@ func (m *IntExemplar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if len(m.TraceId) > 0 {
-		i -= len(m.TraceId)
-		copy(dAtA[i:], m.TraceId)
-		i = encodeVarintMetrics(dAtA, i, uint64(len(m.TraceId)))
-		i--
-		dAtA[i] = 0x2a
+	{
+		size := m.TraceId.Size()
+		i -= size
+		if _, err := m.TraceId.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintMetrics(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0x2a
 	if len(m.SpanId) > 0 {
 		i -= len(m.SpanId)
 		copy(dAtA[i:], m.SpanId)
@@ -2547,13 +2542,16 @@ func (m *DoubleExemplar) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	_ = i
 	var l int
 	_ = l
-	if len(m.TraceId) > 0 {
-		i -= len(m.TraceId)
-		copy(dAtA[i:], m.TraceId)
-		i = encodeVarintMetrics(dAtA, i, uint64(len(m.TraceId)))
-		i--
-		dAtA[i] = 0x2a
+	{
+		size := m.TraceId.Size()
+		i -= size
+		if _, err := m.TraceId.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintMetrics(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0x2a
 	if len(m.SpanId) > 0 {
 		i -= len(m.SpanId)
 		copy(dAtA[i:], m.SpanId)
@@ -3003,10 +3001,8 @@ func (m *IntExemplar) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovMetrics(uint64(l))
 	}
-	l = len(m.TraceId)
-	if l > 0 {
-		n += 1 + l + sovMetrics(uint64(l))
-	}
+	l = m.TraceId.Size()
+	n += 1 + l + sovMetrics(uint64(l))
 	return n
 }
 
@@ -3032,10 +3028,8 @@ func (m *DoubleExemplar) Size() (n int) {
 	if l > 0 {
 		n += 1 + l + sovMetrics(uint64(l))
 	}
-	l = len(m.TraceId)
-	if l > 0 {
-		n += 1 + l + sovMetrics(uint64(l))
-	}
+	l = m.TraceId.Size()
+	n += 1 + l + sovMetrics(uint64(l))
 	return n
 }
 
@@ -5272,9 +5266,8 @@ func (m *IntExemplar) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
-			if m.TraceId == nil {
-				m.TraceId = []byte{}
+			if err := m.TraceId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		default:
@@ -5448,9 +5441,8 @@ func (m *DoubleExemplar) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
-			if m.TraceId == nil {
-				m.TraceId = []byte{}
+			if err := m.TraceId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		default:
diff --git a/internal/data/opentelemetry-proto-gen/trace/v1/trace.pb.go b/internal/data/opentelemetry-proto-gen/trace/v1/trace.pb.go
index d16713c4698..1ddf1c91ae0 100644
--- a/internal/data/opentelemetry-proto-gen/trace/v1/trace.pb.go
+++ b/internal/data/opentelemetry-proto-gen/trace/v1/trace.pb.go
@@ -13,6 +13,7 @@ import (
 	_ "github.com/gogo/protobuf/gogoproto"
 	proto "github.com/gogo/protobuf/proto"
 
+	go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v11 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/resource/v1"
 )
@@ -283,7 +284,7 @@ type Span struct {
 	// random trace_id if empty or invalid trace_id was received.
 	//
 	// This field is required.
-	TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	TraceId go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1.TraceID" json:"trace_id"`
 	// A unique identifier for a span within a trace, assigned when the span
 	// is created. The ID is an 8-byte array. An ID with all zeroes is considered
 	// invalid.
@@ -395,13 +396,6 @@ func (m *Span) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Span proto.InternalMessageInfo
 
-func (m *Span) GetTraceId() []byte {
-	if m != nil {
-		return m.TraceId
-	}
-	return nil
-}
-
 func (m *Span) GetSpanId() []byte {
 	if m != nil {
 		return m.SpanId
@@ -583,7 +577,7 @@ func (m *Span_Event) GetDroppedAttributesCount() uint32 {
 type Span_Link struct {
 	// A unique identifier of a trace that this linked span is part of. The ID is a
 	// 16-byte array.
-	TraceId []byte `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
+	TraceId go_opentelemetry_io_collector_internal_data_opentelemetry_proto_gen_common_v1.TraceID `protobuf:"bytes,1,opt,name=trace_id,json=traceId,proto3,customtype=go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1.TraceID" json:"trace_id"`
 	// A unique identifier for the linked span. The ID is an 8-byte array.
 	SpanId []byte `protobuf:"bytes,2,opt,name=span_id,json=spanId,proto3" json:"span_id,omitempty"`
 	// The trace_state associated with the link.
@@ -628,13 +622,6 @@ func (m *Span_Link) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_Span_Link proto.InternalMessageInfo
 
-func (m *Span_Link) GetTraceId() []byte {
-	if m != nil {
-		return m.TraceId
-	}
-	return nil
-}
-
 func (m *Span_Link) GetSpanId() []byte {
 	if m != nil {
 		return m.SpanId
@@ -736,78 +723,81 @@ func init() {
 }
 
 var fileDescriptor_5c407ac9c675a601 = []byte{
-	// 1133 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x56, 0x4d, 0x6f, 0xdb, 0x46,
-	0x10, 0x35, 0x6d, 0x4a, 0x76, 0xc6, 0x1f, 0x61, 0x36, 0x69, 0xcc, 0xd8, 0x89, 0xac, 0xaa, 0x01,
+	// 1172 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x56, 0xcd, 0x6e, 0xdb, 0x46,
+	0x10, 0x36, 0x6d, 0x49, 0x76, 0xc6, 0x3f, 0x61, 0x36, 0x69, 0xcc, 0xd8, 0x89, 0xa4, 0xaa, 0x01,
 	0xaa, 0x36, 0x88, 0x54, 0x3b, 0x2d, 0x90, 0x02, 0x2d, 0x1a, 0x9a, 0x5c, 0x27, 0x84, 0x69, 0x52,
-	0x58, 0x92, 0x6e, 0xda, 0x0b, 0x41, 0x9b, 0x5b, 0x97, 0x88, 0xb4, 0x14, 0x48, 0xca, 0x48, 0x0e,
-	0xfd, 0x0f, 0xbd, 0xe4, 0x50, 0xa0, 0x3f, 0xa7, 0x40, 0x7b, 0xcc, 0xa5, 0x40, 0x4f, 0x45, 0x91,
-	0xfc, 0x90, 0x16, 0xbb, 0xa4, 0x6c, 0x51, 0x75, 0x94, 0x5c, 0x7c, 0xb1, 0x97, 0x6f, 0xde, 0x9b,
-	0x37, 0x33, 0x3b, 0x84, 0x08, 0xed, 0x64, 0x48, 0x59, 0x4e, 0xfb, 0x74, 0x40, 0xf3, 0xf4, 0x45,
-	0x77, 0x98, 0x26, 0x79, 0xd2, 0xcd, 0xd3, 0xf0, 0x98, 0x76, 0x4f, 0xb7, 0x8b, 0x43, 0x47, 0x80,
-	0xe8, 0x76, 0x85, 0x59, 0x80, 0x9d, 0x82, 0x70, 0xba, 0xbd, 0xf1, 0xf9, 0x49, 0x9c, 0xff, 0x38,
-	0x3a, 0xea, 0x1c, 0x27, 0x83, 0xee, 0x49, 0x72, 0x92, 0x14, 0x99, 0x8e, 0x46, 0x3f, 0x3c, 0x3a,
-	0xdd, 0xee, 0x3c, 0xe8, 0x6c, 0x0b, 0xb0, 0xc8, 0xce, 0x4f, 0x85, 0x7c, 0xe3, 0xd3, 0x8b, 0xdc,
-	0x8f, 0x93, 0xc1, 0x20, 0x61, 0xdc, 0xbe, 0x38, 0x95, 0xdc, 0xce, 0x45, 0xdc, 0x94, 0x66, 0xc9,
-	0x28, 0x2d, 0x8a, 0x1d, 0x9f, 0x0b, 0x7e, 0xeb, 0x4f, 0x09, 0x56, 0x49, 0x09, 0xb9, 0xc3, 0x90,
-	0x65, 0x08, 0xc3, 0xd2, 0x98, 0xa3, 0x4a, 0x4d, 0xa9, 0xbd, 0xbc, 0xf3, 0x49, 0xe7, 0xa2, 0xa6,
-	0xce, 0x12, 0x9d, 0x6e, 0x77, 0xc6, 0x19, 0xc8, 0x99, 0x14, 0xfd, 0x04, 0x77, 0x62, 0x96, 0xe5,
-	0xe9, 0x68, 0x40, 0x59, 0x1e, 0xe6, 0x71, 0xc2, 0x82, 0x7e, 0x7c, 0x94, 0x86, 0xe9, 0x8b, 0x20,
-	0xe3, 0x3e, 0xea, 0x7c, 0x73, 0xa1, 0xbd, 0xbc, 0xf3, 0x65, 0x67, 0xd6, 0xc0, 0x3a, 0x66, 0x35,
-	0x85, 0x55, 0x64, 0x10, 0x85, 0x92, 0xcd, 0xf8, 0xed, 0xc1, 0xd6, 0xef, 0x12, 0x6c, 0xce, 0x10,
-	0x23, 0x06, 0xeb, 0x6f, 0x29, 0xaf, 0x6c, 0xfa, 0x8b, 0x0b, 0x0b, 0x2b, 0x67, 0xfd, 0xd6, 0xca,
-	0xc8, 0xcd, 0x8b, 0x8b, 0x42, 0x0f, 0xa1, 0x36, 0xd9, 0x76, 0x6b, 0x76, 0xdb, 0xbc, 0x46, 0x52,
-	0x08, 0x5a, 0xbf, 0x02, 0xc8, 0xfc, 0x19, 0xdd, 0x82, 0x25, 0x41, 0x08, 0xe2, 0x48, 0xd4, 0xb8,
-	0x42, 0x16, 0xc5, 0xb3, 0x19, 0xa1, 0x75, 0x58, 0xe4, 0x64, 0x1e, 0x99, 0x17, 0x91, 0x3a, 0x7f,
-	0x34, 0x23, 0xb4, 0x05, 0xcb, 0x85, 0x26, 0xcb, 0xc3, 0x9c, 0xaa, 0x0b, 0x4d, 0xa9, 0x7d, 0x85,
-	0x80, 0x80, 0x5c, 0x8e, 0xa0, 0xbb, 0xb0, 0x36, 0x0c, 0x53, 0xca, 0xf2, 0x60, 0x9c, 0x40, 0x16,
-	0x09, 0x56, 0x0a, 0xd4, 0x2d, 0xd2, 0x20, 0x90, 0x59, 0x38, 0xa0, 0x6a, 0x4d, 0xe8, 0xc5, 0x19,
-	0x7d, 0x03, 0xf2, 0xb3, 0x98, 0x45, 0x6a, 0xbd, 0x29, 0xb5, 0xd7, 0x76, 0xee, 0xbd, 0xbb, 0x21,
-	0xf1, 0x67, 0x3f, 0x66, 0x11, 0x11, 0x42, 0xd4, 0x85, 0x1b, 0x59, 0x1e, 0xa6, 0x79, 0x90, 0xc7,
-	0x03, 0x1a, 0x8c, 0x58, 0xfc, 0x3c, 0x60, 0x21, 0x4b, 0xd4, 0xc5, 0xa6, 0xd4, 0xae, 0x93, 0x6b,
-	0x22, 0xe6, 0xc5, 0x03, 0xea, 0xb3, 0xf8, 0xb9, 0x1d, 0xb2, 0x04, 0xdd, 0x03, 0x44, 0x59, 0x34,
-	0x4d, 0x5f, 0x12, 0xf4, 0xab, 0x94, 0x45, 0x15, 0xf2, 0x63, 0x80, 0x30, 0xcf, 0xd3, 0xf8, 0x68,
-	0x94, 0xd3, 0x4c, 0xbd, 0x22, 0xa6, 0xfe, 0xf1, 0x3b, 0xee, 0x74, 0x9f, 0xbe, 0x38, 0x0c, 0xfb,
-	0x23, 0x4a, 0x26, 0xa4, 0xe8, 0x21, 0xa8, 0x51, 0x9a, 0x0c, 0x87, 0x34, 0x0a, 0xce, 0xd1, 0xe0,
-	0x38, 0x19, 0xb1, 0x5c, 0x85, 0xa6, 0xd4, 0x5e, 0x25, 0x37, 0xcb, 0xb8, 0x76, 0x16, 0xd6, 0x79,
-	0x14, 0x3d, 0x82, 0x3a, 0x3d, 0xa5, 0x2c, 0xcf, 0xd4, 0x65, 0x61, 0xdf, 0x7e, 0x8f, 0x19, 0x61,
-	0x2e, 0x20, 0xa5, 0x0e, 0x7d, 0x06, 0x37, 0xc6, 0xde, 0x05, 0x52, 0xfa, 0xae, 0x08, 0x5f, 0x54,
-	0xc6, 0x84, 0xa6, 0xf4, 0xfc, 0x1a, 0x6a, 0xfd, 0x98, 0x3d, 0xcb, 0xd4, 0xd5, 0x19, 0x1d, 0x57,
-	0x2d, 0xad, 0x98, 0x3d, 0x23, 0x85, 0x0a, 0x75, 0xe0, 0xfa, 0xd8, 0x50, 0x00, 0xa5, 0xdf, 0x9a,
-	0xf0, 0xbb, 0x56, 0x86, 0xb8, 0xa0, 0xb4, 0xfb, 0x0a, 0xea, 0x7c, 0xb3, 0x46, 0x99, 0x7a, 0x55,
-	0xbc, 0x35, 0x77, 0xdf, 0xe1, 0x27, 0xb8, 0xa4, 0xd4, 0x6c, 0xfc, 0x26, 0x41, 0x4d, 0x14, 0xcf,
-	0xd7, 0x70, 0xea, 0x5a, 0x25, 0x71, 0xad, 0x2b, 0xf9, 0xe4, 0x9d, 0x8e, 0xd7, 0x70, 0x7e, 0x62,
-	0x0d, 0xab, 0xf7, 0xbc, 0x70, 0x39, 0xf7, 0x2c, 0xcf, 0xba, 0xe7, 0x8d, 0xbf, 0x25, 0x90, 0xf9,
-	0x4c, 0x2e, 0xe7, 0x0d, 0xad, 0x36, 0x28, 0x5f, 0x4e, 0x83, 0xb5, 0x59, 0x0d, 0xb6, 0x7e, 0x91,
-	0x60, 0x69, 0xfc, 0xf2, 0xa2, 0x5b, 0xf0, 0x81, 0xdb, 0xd3, 0xec, 0x60, 0xdf, 0xb4, 0x8d, 0xc0,
-	0xb7, 0xdd, 0x1e, 0xd6, 0xcd, 0x3d, 0x13, 0x1b, 0xca, 0x1c, 0xba, 0x09, 0xe8, 0x3c, 0x64, 0xda,
-	0x1e, 0x26, 0xb6, 0x66, 0x29, 0x12, 0xba, 0x01, 0xca, 0x39, 0xee, 0x62, 0x72, 0x88, 0x89, 0x32,
-	0x5f, 0x45, 0x75, 0xcb, 0xc4, 0xb6, 0xa7, 0x2c, 0x54, 0x73, 0xf4, 0x88, 0x63, 0xf8, 0x3a, 0x26,
-	0x8a, 0x5c, 0xc5, 0x75, 0xc7, 0x76, 0xfd, 0x03, 0x4c, 0x94, 0x5a, 0xeb, 0x5f, 0x19, 0xea, 0xc5,
-	0x5a, 0x21, 0x1d, 0xe4, 0xe3, 0x24, 0x2a, 0x7e, 0xb5, 0xd6, 0x76, 0xba, 0xef, 0xb3, 0x8a, 0xe5,
-	0x3f, 0x3d, 0x89, 0x28, 0x11, 0x62, 0xa4, 0xc2, 0xe2, 0x80, 0x66, 0x59, 0x78, 0x32, 0x5e, 0xb3,
-	0xf1, 0x63, 0xeb, 0xa5, 0x0c, 0x70, 0x4e, 0x47, 0x08, 0xd6, 0x5c, 0x4f, 0xf3, 0x7c, 0x37, 0xd0,
-	0x1d, 0x03, 0x07, 0xce, 0xbe, 0x32, 0x27, 0x66, 0x33, 0x81, 0xe9, 0x9a, 0xad, 0x63, 0xcb, 0xc2,
-	0x86, 0x22, 0xa1, 0x3b, 0x70, 0x6b, 0x32, 0xe4, 0xdb, 0xfb, 0xb6, 0xf3, 0xad, 0x1d, 0x60, 0x42,
-	0x1c, 0x3e, 0x8c, 0x26, 0xdc, 0x9e, 0x0c, 0x9b, 0xf6, 0xa1, 0x66, 0x99, 0x46, 0xa0, 0x91, 0xc7,
-	0xfe, 0x41, 0x31, 0x98, 0x0f, 0xe1, 0xce, 0x24, 0xc3, 0xc0, 0x9a, 0x61, 0x99, 0x36, 0x0e, 0xf0,
-	0x53, 0x1d, 0x63, 0x03, 0x1b, 0x8a, 0x3c, 0x6d, 0x6f, 0x3b, 0x5e, 0xb0, 0xe7, 0xf8, 0xb6, 0xa1,
-	0xd4, 0x50, 0x03, 0x36, 0x26, 0x43, 0x9a, 0x45, 0xb0, 0x66, 0x7c, 0x17, 0xe0, 0xa7, 0xa6, 0xeb,
-	0xb9, 0x4a, 0x7d, 0x3a, 0x7b, 0x0f, 0x93, 0x03, 0xd3, 0x75, 0x4d, 0xc7, 0x0e, 0x0c, 0x6c, 0xf3,
-	0xdb, 0x5d, 0x44, 0x2d, 0x68, 0x4c, 0x52, 0x08, 0x76, 0x1d, 0x9f, 0xe8, 0xbc, 0x80, 0x27, 0x9a,
-	0xef, 0x7a, 0xd8, 0x50, 0x96, 0xd0, 0x47, 0xb0, 0x35, 0xc9, 0xd9, 0xd3, 0x4c, 0x0b, 0xf3, 0x6b,
-	0xc4, 0xba, 0x63, 0x1b, 0xa6, 0x67, 0x3a, 0xb6, 0x72, 0x05, 0xad, 0xc3, 0xf5, 0x4a, 0x2d, 0xbb,
-	0x0e, 0xe1, 0x6a, 0x40, 0xb7, 0x41, 0xad, 0x8c, 0xd4, 0xf7, 0x02, 0x67, 0x2f, 0x20, 0x9a, 0xfd,
-	0x18, 0x2b, 0xcb, 0xff, 0x9f, 0xa0, 0x79, 0xd0, 0xb3, 0x30, 0x9f, 0x0e, 0x36, 0x94, 0x95, 0xe9,
-	0x0e, 0xc7, 0xeb, 0x57, 0x4e, 0x78, 0x15, 0x6d, 0xc2, 0x7a, 0x55, 0xae, 0x1d, 0x6a, 0xa6, 0xa5,
-	0xed, 0x5a, 0x58, 0x59, 0x9b, 0x9e, 0x9c, 0xa1, 0x79, 0x5a, 0x60, 0x39, 0xae, 0xab, 0x5c, 0x45,
-	0x5b, 0xb0, 0x39, 0xa5, 0xf3, 0xbd, 0x27, 0xd8, 0xf6, 0x4c, 0x5d, 0xe3, 0xc6, 0xca, 0xee, 0x4b,
-	0xe9, 0x8f, 0xd7, 0x0d, 0xe9, 0xd5, 0xeb, 0x86, 0xf4, 0xcf, 0xeb, 0x86, 0xf4, 0xf3, 0x9b, 0xc6,
-	0xdc, 0xab, 0x37, 0x8d, 0xb9, 0xbf, 0xde, 0x34, 0xe6, 0x60, 0x2b, 0x4e, 0x66, 0x6e, 0xe1, 0x2e,
-	0x78, 0xfc, 0xd4, 0xe3, 0x60, 0x4f, 0xfa, 0xde, 0x3a, 0x99, 0xa6, 0xc7, 0xfc, 0x43, 0xaf, 0xdf,
-	0xa7, 0xc7, 0x79, 0x92, 0x76, 0x63, 0x96, 0xd3, 0x94, 0x85, 0xfd, 0x6e, 0x14, 0xe6, 0x61, 0xb7,
-	0x42, 0xbc, 0x2f, 0xf2, 0xde, 0x3f, 0xa1, 0xec, 0xec, 0xb3, 0xf4, 0xa8, 0x2e, 0xb0, 0x07, 0xff,
-	0x05, 0x00, 0x00, 0xff, 0xff, 0x87, 0x78, 0xa8, 0x55, 0xbd, 0x0a, 0x00, 0x00,
+	0x58, 0x92, 0x6e, 0xda, 0x0b, 0x41, 0x5b, 0x5b, 0x87, 0x88, 0xb4, 0x34, 0xa8, 0x95, 0x91, 0x1c,
+	0x7a, 0xea, 0x0b, 0xf4, 0x92, 0x43, 0xdf, 0xa7, 0x40, 0xd3, 0x5b, 0x2e, 0x05, 0x8a, 0x1e, 0x82,
+	0xc2, 0x79, 0x83, 0xbe, 0x40, 0x8b, 0x5d, 0x52, 0xb1, 0xa8, 0x3a, 0x72, 0x0e, 0xcd, 0xa1, 0x17,
+	0x7b, 0x39, 0xf3, 0x7d, 0xf3, 0xcd, 0x7e, 0x33, 0xa2, 0x04, 0xcd, 0xe4, 0x88, 0x32, 0x4e, 0x7b,
+	0xb4, 0x4f, 0x79, 0xfa, 0xb4, 0x7d, 0x94, 0x26, 0x3c, 0x69, 0xf3, 0x34, 0x3a, 0xa0, 0xed, 0xe3,
+	0x8d, 0xec, 0xd0, 0x92, 0x41, 0x74, 0xbd, 0x80, 0xcc, 0x82, 0xad, 0x0c, 0x70, 0xbc, 0xb1, 0xf6,
+	0xe9, 0x61, 0xcc, 0x1f, 0x0d, 0xf7, 0x5b, 0x07, 0x49, 0xbf, 0x7d, 0x98, 0x1c, 0x26, 0x59, 0xa5,
+	0xfd, 0xe1, 0x77, 0xf7, 0x8e, 0x37, 0x5a, 0x77, 0x5a, 0x1b, 0x32, 0x98, 0x55, 0x17, 0xa7, 0x8c,
+	0xbe, 0xf6, 0xf1, 0x59, 0xea, 0x07, 0x49, 0xbf, 0x9f, 0x30, 0x21, 0x9f, 0x9d, 0x72, 0x6c, 0xeb,
+	0x2c, 0x6c, 0x4a, 0x07, 0xc9, 0x30, 0xcd, 0x9a, 0x1d, 0x9d, 0x33, 0x7c, 0xe3, 0x37, 0x05, 0x96,
+	0x49, 0x1e, 0xf2, 0x8e, 0x22, 0x36, 0x40, 0x18, 0x16, 0x46, 0x18, 0x4d, 0xa9, 0x2b, 0xcd, 0xc5,
+	0xcd, 0x8f, 0x5a, 0x67, 0x5d, 0xea, 0x75, 0xa1, 0xe3, 0x8d, 0xd6, 0xa8, 0x02, 0x79, 0x4d, 0x45,
+	0xdf, 0xc3, 0x8d, 0x98, 0x0d, 0x78, 0x3a, 0xec, 0x53, 0xc6, 0x23, 0x1e, 0x27, 0x2c, 0xec, 0xc5,
+	0xfb, 0x69, 0x94, 0x3e, 0x0d, 0x07, 0x42, 0x47, 0x9b, 0xad, 0xcf, 0x35, 0x17, 0x37, 0x3f, 0x6f,
+	0x4d, 0x33, 0xac, 0x65, 0x15, 0x4b, 0xd8, 0x59, 0x05, 0xd9, 0x28, 0x59, 0x8f, 0xdf, 0x9c, 0x6c,
+	0xfc, 0xa2, 0xc0, 0xfa, 0x14, 0x32, 0x62, 0xb0, 0xfa, 0x86, 0xf6, 0xf2, 0x4b, 0x7f, 0x76, 0x66,
+	0x63, 0xb9, 0xd7, 0x6f, 0xec, 0x8c, 0x5c, 0x3d, 0xbb, 0x29, 0x74, 0x17, 0xca, 0xe3, 0xd7, 0x6e,
+	0x4c, 0xbf, 0xb6, 0xe8, 0x91, 0x64, 0x84, 0xc6, 0x5f, 0x8b, 0x50, 0x12, 0xcf, 0xe8, 0x07, 0x05,
+	0x16, 0x24, 0x22, 0x8c, 0xbb, 0xb2, 0xc9, 0xa5, 0xad, 0x47, 0xcf, 0x5f, 0xd6, 0x66, 0xfe, 0x78,
+	0x59, 0x0b, 0x0e, 0x93, 0x89, 0x82, 0xb1, 0xd8, 0x90, 0x5e, 0x8f, 0x1e, 0xf0, 0x24, 0x6d, 0xc7,
+	0x8c, 0xd3, 0x94, 0x45, 0xbd, 0x76, 0x37, 0xe2, 0x51, 0xbb, 0x00, 0xbc, 0x2d, 0x95, 0x6f, 0x1f,
+	0x52, 0x76, 0xba, 0x51, 0x2d, 0x5f, 0xa8, 0x58, 0xe6, 0xc9, 0xcb, 0xda, 0x7c, 0x76, 0xec, 0x92,
+	0x79, 0x9e, 0x1d, 0xd0, 0x2a, 0xcc, 0x8b, 0xbe, 0x44, 0x0f, 0xb3, 0xa2, 0x07, 0x52, 0x11, 0x8f,
+	0x56, 0x17, 0xd5, 0x60, 0x31, 0xeb, 0x6e, 0xc0, 0x23, 0x4e, 0xb5, 0xb9, 0xba, 0xd2, 0xbc, 0x40,
+	0x40, 0x86, 0x3c, 0x11, 0x41, 0x37, 0x61, 0xe5, 0x28, 0x4a, 0x29, 0xe3, 0xe1, 0xa8, 0x40, 0x49,
+	0x16, 0x58, 0xca, 0xa2, 0x5e, 0x56, 0x06, 0x41, 0x89, 0x45, 0x7d, 0xaa, 0x95, 0x25, 0x5f, 0x9e,
+	0xd1, 0x57, 0x50, 0x7a, 0x1c, 0xb3, 0xae, 0x56, 0xa9, 0x2b, 0xcd, 0x95, 0xcd, 0x5b, 0xe7, 0x7b,
+	0x27, 0xff, 0xec, 0xc4, 0xac, 0x4b, 0x24, 0x11, 0xb5, 0xe1, 0xca, 0x80, 0x47, 0x29, 0x0f, 0x79,
+	0xdc, 0xa7, 0xe1, 0x90, 0xc5, 0x4f, 0x42, 0x16, 0xb1, 0x44, 0x9b, 0xaf, 0x2b, 0xcd, 0x0a, 0xb9,
+	0x24, 0x73, 0x7e, 0xdc, 0xa7, 0x01, 0x8b, 0x9f, 0x38, 0x11, 0x4b, 0xd0, 0x2d, 0x40, 0x94, 0x75,
+	0x27, 0xe1, 0x0b, 0x12, 0x7e, 0x91, 0xb2, 0x6e, 0x01, 0x7c, 0x1f, 0x20, 0xe2, 0x3c, 0x8d, 0xf7,
+	0x87, 0x9c, 0x0e, 0xb4, 0x0b, 0x72, 0xc0, 0x1f, 0x9e, 0xb3, 0x3e, 0x3b, 0xf4, 0xe9, 0x5e, 0xd4,
+	0x1b, 0x52, 0x32, 0x46, 0x45, 0x77, 0x41, 0xeb, 0xa6, 0xc9, 0xd1, 0x11, 0xed, 0x86, 0xa7, 0xd1,
+	0xf0, 0x20, 0x19, 0x32, 0xae, 0x41, 0x5d, 0x69, 0x2e, 0x93, 0xab, 0x79, 0x5e, 0x7f, 0x9d, 0x36,
+	0x44, 0x16, 0xdd, 0x83, 0x0a, 0x3d, 0xa6, 0x8c, 0x0f, 0xb4, 0x45, 0x29, 0xdf, 0x7c, 0x0b, 0x8f,
+	0xb0, 0x20, 0x90, 0x9c, 0x87, 0x3e, 0x81, 0x2b, 0x23, 0xed, 0x2c, 0x92, 0xeb, 0x2e, 0x49, 0x5d,
+	0x94, 0xe7, 0x24, 0x27, 0xd7, 0xfc, 0x12, 0xca, 0xbd, 0x98, 0x3d, 0x1e, 0x68, 0xcb, 0x53, 0x6e,
+	0x5c, 0x94, 0xb4, 0x63, 0xf6, 0x98, 0x64, 0x2c, 0xd4, 0x82, 0xcb, 0x23, 0x41, 0x19, 0xc8, 0xf5,
+	0x56, 0xa4, 0xde, 0xa5, 0x3c, 0x25, 0x08, 0xb9, 0xdc, 0x17, 0x50, 0x11, 0x9b, 0x35, 0x1c, 0x68,
+	0x17, 0xe5, 0x07, 0xf4, 0xe6, 0x39, 0x7a, 0x12, 0x4b, 0x72, 0xce, 0xda, 0xcf, 0x0a, 0x94, 0x65,
+	0xf3, 0x62, 0x0d, 0x27, 0xc6, 0xaa, 0xc8, 0xb1, 0x2e, 0xf1, 0xf1, 0x99, 0x8e, 0xd6, 0x70, 0x76,
+	0x6c, 0x0d, 0x8b, 0x73, 0x9e, 0x7b, 0x37, 0x73, 0x2e, 0x4d, 0x9b, 0xf3, 0xda, 0xaf, 0xb3, 0x50,
+	0x12, 0x9e, 0xfc, 0xef, 0x5f, 0x06, 0x45, 0x2f, 0x4b, 0xef, 0xc6, 0xcb, 0xf2, 0x34, 0x2f, 0x1b,
+	0x3f, 0x29, 0xb0, 0x30, 0x7a, 0x4f, 0xa0, 0x6b, 0xf0, 0x9e, 0xd7, 0xd1, 0x9d, 0x70, 0xc7, 0x72,
+	0xcc, 0x30, 0x70, 0xbc, 0x0e, 0x36, 0xac, 0x6d, 0x0b, 0x9b, 0xea, 0x0c, 0xba, 0x0a, 0xe8, 0x34,
+	0x65, 0x39, 0x3e, 0x26, 0x8e, 0x6e, 0xab, 0x0a, 0xba, 0x02, 0xea, 0x69, 0xdc, 0xc3, 0x64, 0x0f,
+	0x13, 0x75, 0xb6, 0x18, 0x35, 0x6c, 0x0b, 0x3b, 0xbe, 0x3a, 0x57, 0xac, 0xd1, 0x21, 0xae, 0x19,
+	0x18, 0x98, 0xa8, 0xa5, 0x62, 0xdc, 0x70, 0x1d, 0x2f, 0xd8, 0xc5, 0x44, 0x2d, 0x37, 0xfe, 0x2e,
+	0x41, 0x25, 0xdb, 0x60, 0x64, 0x40, 0xe9, 0x20, 0xe9, 0x66, 0xdf, 0xc5, 0x2b, 0x9b, 0xed, 0xb7,
+	0xd9, 0xfa, 0xfc, 0x9f, 0x91, 0x74, 0x29, 0x91, 0x64, 0xa4, 0xc1, 0x7c, 0x9f, 0x0e, 0x06, 0xd1,
+	0xe1, 0x68, 0xa3, 0x47, 0x8f, 0x8d, 0x67, 0x25, 0x80, 0x53, 0x38, 0x42, 0xb0, 0xe2, 0xf9, 0xba,
+	0x1f, 0x78, 0xa1, 0xe1, 0x9a, 0x38, 0x74, 0x77, 0xd4, 0x19, 0xe9, 0xcd, 0x58, 0xcc, 0xd0, 0x1d,
+	0x03, 0xdb, 0x36, 0x36, 0x55, 0x05, 0xdd, 0x80, 0x6b, 0xe3, 0xa9, 0xc0, 0xd9, 0x71, 0xdc, 0xaf,
+	0x9d, 0x10, 0x13, 0xe2, 0x0a, 0x33, 0xea, 0x70, 0x7d, 0x3c, 0x6d, 0x39, 0x7b, 0xba, 0x6d, 0x99,
+	0xa1, 0x4e, 0xee, 0x07, 0xbb, 0x99, 0x31, 0xef, 0xc3, 0x8d, 0x71, 0x84, 0x89, 0x75, 0xd3, 0xb6,
+	0x1c, 0x1c, 0xe2, 0x87, 0x06, 0xc6, 0x26, 0x36, 0xd5, 0xd2, 0xa4, 0xbc, 0xe3, 0xfa, 0xe1, 0xb6,
+	0x1b, 0x38, 0xa6, 0x5a, 0x46, 0x55, 0x58, 0x1b, 0x4f, 0xe9, 0x36, 0xc1, 0xba, 0xf9, 0x4d, 0x88,
+	0x1f, 0x5a, 0x9e, 0xef, 0xa9, 0x95, 0xc9, 0xea, 0x1d, 0x4c, 0x76, 0x2d, 0xcf, 0xb3, 0x5c, 0x27,
+	0x34, 0xb1, 0x23, 0xa6, 0x3b, 0x8f, 0x1a, 0x50, 0x1d, 0x87, 0x10, 0xec, 0xb9, 0x01, 0x31, 0x44,
+	0x03, 0x0f, 0xf4, 0xc0, 0xf3, 0xb1, 0xa9, 0x2e, 0xa0, 0x0f, 0xa0, 0x36, 0x8e, 0xd9, 0xd6, 0x2d,
+	0x1b, 0x8b, 0x31, 0x62, 0xc3, 0x75, 0x4c, 0xcb, 0xb7, 0x5c, 0x47, 0xbd, 0x80, 0x56, 0xe1, 0x72,
+	0xa1, 0x97, 0x2d, 0x97, 0x08, 0x36, 0xa0, 0xeb, 0xa0, 0x15, 0x2c, 0x0d, 0xfc, 0xd0, 0xdd, 0x0e,
+	0x89, 0xee, 0xdc, 0xc7, 0xea, 0xe2, 0xbf, 0x1d, 0xb4, 0x76, 0x3b, 0x36, 0x16, 0xee, 0x60, 0x53,
+	0x5d, 0x9a, 0xbc, 0xe1, 0x68, 0xfd, 0x72, 0x87, 0x97, 0xd1, 0x3a, 0xac, 0x16, 0xe9, 0xfa, 0x9e,
+	0x6e, 0xd9, 0xfa, 0x96, 0x8d, 0xd5, 0x95, 0x49, 0xe7, 0x4c, 0xdd, 0xd7, 0x43, 0xdb, 0xf5, 0x3c,
+	0xf5, 0x22, 0xaa, 0xc1, 0xfa, 0x04, 0x2f, 0xf0, 0x1f, 0x60, 0xc7, 0xb7, 0x0c, 0x5d, 0x08, 0xab,
+	0x5b, 0xcf, 0x94, 0xe7, 0x27, 0x55, 0xe5, 0xc5, 0x49, 0x55, 0xf9, 0xf3, 0xa4, 0xaa, 0xfc, 0xf8,
+	0xaa, 0x3a, 0xf3, 0xe2, 0x55, 0x75, 0xe6, 0xf7, 0x57, 0xd5, 0x19, 0xa8, 0xc5, 0xc9, 0xd4, 0x2d,
+	0xdc, 0x02, 0xf9, 0xa2, 0xe8, 0x88, 0x60, 0x47, 0xf9, 0xd6, 0xfe, 0x2f, 0xde, 0x47, 0xa3, 0x1f,
+	0xdb, 0xfb, 0x15, 0x19, 0xbb, 0xf3, 0x4f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x7d, 0x0f, 0x03, 0xf1,
+	0x93, 0x0b, 0x00, 0x00,
 }
 
 func (m *ResourceSpans) Marshal() (dAtA []byte, err error) {
@@ -1042,13 +1032,16 @@ func (m *Span) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(m.TraceId) > 0 {
-		i -= len(m.TraceId)
-		copy(dAtA[i:], m.TraceId)
-		i = encodeVarintTrace(dAtA, i, uint64(len(m.TraceId)))
-		i--
-		dAtA[i] = 0xa
+	{
+		size := m.TraceId.Size()
+		i -= size
+		if _, err := m.TraceId.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintTrace(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
@@ -1160,13 +1153,16 @@ func (m *Span_Link) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i--
 		dAtA[i] = 0x12
 	}
-	if len(m.TraceId) > 0 {
-		i -= len(m.TraceId)
-		copy(dAtA[i:], m.TraceId)
-		i = encodeVarintTrace(dAtA, i, uint64(len(m.TraceId)))
-		i--
-		dAtA[i] = 0xa
+	{
+		size := m.TraceId.Size()
+		i -= size
+		if _, err := m.TraceId.MarshalTo(dAtA[i:]); err != nil {
+			return 0, err
+		}
+		i = encodeVarintTrace(dAtA, i, uint64(size))
 	}
+	i--
+	dAtA[i] = 0xa
 	return len(dAtA) - i, nil
 }
 
@@ -1260,10 +1256,8 @@ func (m *Span) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.TraceId)
-	if l > 0 {
-		n += 1 + l + sovTrace(uint64(l))
-	}
+	l = m.TraceId.Size()
+	n += 1 + l + sovTrace(uint64(l))
 	l = len(m.SpanId)
 	if l > 0 {
 		n += 1 + l + sovTrace(uint64(l))
@@ -1354,10 +1348,8 @@ func (m *Span_Link) Size() (n int) {
 	}
 	var l int
 	_ = l
-	l = len(m.TraceId)
-	if l > 0 {
-		n += 1 + l + sovTrace(uint64(l))
-	}
+	l = m.TraceId.Size()
+	n += 1 + l + sovTrace(uint64(l))
 	l = len(m.SpanId)
 	if l > 0 {
 		n += 1 + l + sovTrace(uint64(l))
@@ -1704,9 +1696,8 @@ func (m *Span) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
-			if m.TraceId == nil {
-				m.TraceId = []byte{}
+			if err := m.TraceId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 2:
@@ -2305,9 +2296,8 @@ func (m *Span_Link) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			m.TraceId = append(m.TraceId[:0], dAtA[iNdEx:postIndex]...)
-			if m.TraceId == nil {
-				m.TraceId = []byte{}
+			if err := m.TraceId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
 			}
 			iNdEx = postIndex
 		case 2:
diff --git a/internal/data/testdata/log.go b/internal/data/testdata/log.go
index b7f7c607cc2..1eece8d5616 100644
--- a/internal/data/testdata/log.go
+++ b/internal/data/testdata/log.go
@@ -270,7 +270,7 @@ func fillLogOne(log pdata.LogRecord) {
 	log.SetSeverityNumber(pdata.SeverityNumberINFO)
 	log.SetSeverityText("Info")
 	log.SetSpanID([]byte{0x01, 0x02, 0x04, 0x08})
-	log.SetTraceID([]byte{0x08, 0x04, 0x02, 0x01})
+	log.SetTraceID(pdata.NewTraceID([]byte{0x08, 0x04, 0x02, 0x01}))
 
 	attrs := log.Attributes()
 	attrs.InsertString("app", "server")
@@ -288,7 +288,7 @@ func generateOtlpLogOne() *otlplogs.LogRecord {
 		SeverityText:           "Info",
 		Body:                   &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "This is a log message"}},
 		SpanId:                 []byte{0x01, 0x02, 0x04, 0x08},
-		TraceId:                []byte{0x08, 0x04, 0x02, 0x01},
+		TraceId:                otlpcommon.NewTraceID([]byte{0x08, 0x04, 0x02, 0x01}),
 		Attributes: []*otlpcommon.KeyValue{
 			{
 				Key:   "app",
diff --git a/internal/goldendataset/generator_commons.go b/internal/goldendataset/generator_commons.go
index 919341ea5d3..db09852b81d 100644
--- a/internal/goldendataset/generator_commons.go
+++ b/internal/goldendataset/generator_commons.go
@@ -93,13 +93,13 @@ func loadPictOutputFile(fileName string) ([][]string, error) {
 	return reader.ReadAll()
 }
 
-func generateTraceID(random io.Reader) []byte {
+func generateTraceID(random io.Reader) otlpcommon.TraceID {
 	var r [16]byte
 	_, err := random.Read(r[:])
 	if err != nil {
 		panic(err)
 	}
-	return r[:]
+	return otlpcommon.NewTraceID(r[:])
 }
 
 func generateSpanID(random io.Reader) []byte {
diff --git a/internal/goldendataset/span_generator.go b/internal/goldendataset/span_generator.go
index 070a0c5ccd2..dc96657d385 100644
--- a/internal/goldendataset/span_generator.go
+++ b/internal/goldendataset/span_generator.go
@@ -84,7 +84,7 @@ func GenerateSpans(count int, startPos int, pictFile string, random io.Reader) (
 	index := startPos + 1
 	var inputs []string
 	var spanInputs *PICTSpanInputs
-	var traceID []byte
+	var traceID otlpcommon.TraceID
 	var parentID []byte
 	for i := 0; i < count; i++ {
 		if index >= pairsTotal {
@@ -106,7 +106,7 @@ func GenerateSpans(count int, startPos int, pictFile string, random io.Reader) (
 			parentID = nil
 		case SpanParentChild:
 			// use existing if available
-			if traceID == nil {
+			if traceID.Bytes() == nil {
 				traceID = generateTraceID(random)
 			}
 			if parentID == nil {
@@ -134,7 +134,7 @@ func generateSpanName(spanInputs *PICTSpanInputs) string {
 //   random - the random number generator to use in generating ID values
 //
 // The generated span is returned.
-func GenerateSpan(traceID []byte, parentID []byte, spanName string, spanInputs *PICTSpanInputs,
+func GenerateSpan(traceID otlpcommon.TraceID, parentID []byte, spanName string, spanInputs *PICTSpanInputs,
 	random io.Reader) *otlptrace.Span {
 	endTime := time.Now().Add(-50 * time.Microsecond)
 	return &otlptrace.Span{
diff --git a/processor/groupbytraceprocessor/processor.go b/processor/groupbytraceprocessor/processor.go
index 36d30a5fa74..e7cfdf8a875 100644
--- a/processor/groupbytraceprocessor/processor.go
+++ b/processor/groupbytraceprocessor/processor.go
@@ -124,7 +124,8 @@ func (sp *groupByTraceProcessor) processResourceSpans(rs pdata.ResourceSpans) er
 
 	for _, batch := range splitByTrace(rs) {
 		if err := sp.processBatch(batch); err != nil {
-			sp.logger.Info("failed to process batch", zap.Error(err), zap.Stringer("traceID", batch.traceID))
+			sp.logger.Info("failed to process batch", zap.Error(err),
+				zap.String("traceID", batch.traceID.HexString()))
 		}
 	}
 
@@ -148,7 +149,7 @@ func (sp *groupByTraceProcessor) processBatch(batch *singleTraceBatch) error {
 
 	// place the trace ID in the buffer, and check if an item had to be evicted
 	evicted := sp.ringBuffer.put(traceID)
-	if evicted != nil {
+	if evicted.Bytes() != nil {
 		// delete from the storage
 		sp.eventMachine.fire(event{
 			typ:     traceRemoved,
@@ -156,7 +157,8 @@ func (sp *groupByTraceProcessor) processBatch(batch *singleTraceBatch) error {
 		})
 
 		// TODO: do we want another channel that receives evicted items? record a metric perhaps?
-		sp.logger.Info("trace evicted: in order to avoid this in the future, adjust the wait duration and/or number of traces to keep in memory", zap.Stringer("traceID", evicted))
+		sp.logger.Info("trace evicted: in order to avoid this in the future, adjust the wait duration and/or number of traces to keep in memory",
+			zap.String("traceID", evicted.HexString()))
 	}
 
 	// we have the traceID in the memory, place the spans in the storage too
@@ -178,12 +180,14 @@ func (sp *groupByTraceProcessor) processBatch(batch *singleTraceBatch) error {
 }
 
 func (sp *groupByTraceProcessor) onTraceExpired(traceID pdata.TraceID) error {
-	sp.logger.Debug("processing expired", zap.Stringer("traceID", traceID))
+	sp.logger.Debug("processing expired", zap.String("traceID",
+		traceID.HexString()))
 
 	if !sp.ringBuffer.contains(traceID) {
 		// we likely received multiple batches with spans for the same trace
 		// and released this trace already
-		sp.logger.Debug("skipping the processing of expired trace", zap.Stringer("traceID", traceID))
+		sp.logger.Debug("skipping the processing of expired trace",
+			zap.String("traceID", traceID.HexString()))
 		return nil
 	}
 
@@ -191,7 +195,8 @@ func (sp *groupByTraceProcessor) onTraceExpired(traceID pdata.TraceID) error {
 	sp.ringBuffer.delete(traceID)
 
 	// this might block, but we don't need to wait
-	sp.logger.Debug("marking the trace as released", zap.Stringer("traceID", traceID))
+	sp.logger.Debug("marking the trace as released",
+		zap.String("traceID", traceID.HexString()))
 	go sp.markAsReleased(traceID)
 
 	return nil
@@ -209,7 +214,7 @@ func (sp *groupByTraceProcessor) markAsReleased(traceID pdata.TraceID) error {
 	}
 
 	// signal that the trace is ready to be released
-	sp.logger.Debug("trace marked as released", zap.Stringer("traceID", traceID))
+	sp.logger.Debug("trace marked as released", zap.String("traceID", traceID.HexString()))
 
 	// atomically fire the two events, so that a concurrent shutdown won't leave
 	// an orphaned trace in the storage
@@ -234,18 +239,18 @@ func (sp *groupByTraceProcessor) onTraceReleased(rss []pdata.ResourceSpans) erro
 func (sp *groupByTraceProcessor) onTraceRemoved(traceID pdata.TraceID) error {
 	trace, err := sp.st.delete(traceID)
 	if err != nil {
-		return fmt.Errorf("couldn't delete trace %q from the storage: %w", traceID.String(), err)
+		return fmt.Errorf("couldn't delete trace %q from the storage: %w", traceID.HexString(), err)
 	}
 
 	if trace == nil {
-		return fmt.Errorf("trace %q not found at the storage", traceID.String())
+		return fmt.Errorf("trace %q not found at the storage", traceID.HexString())
 	}
 
 	return nil
 }
 
 func (sp *groupByTraceProcessor) addSpans(traceID pdata.TraceID, trace pdata.ResourceSpans) error {
-	sp.logger.Debug("creating trace at the storage", zap.Stringer("traceID", traceID))
+	sp.logger.Debug("creating trace at the storage", zap.String("traceID", traceID.HexString()))
 	return sp.st.createOrAppend(traceID, trace)
 }
 
@@ -266,13 +271,13 @@ func splitByTrace(rs pdata.ResourceSpans) []*singleTraceBatch {
 		ils := rs.InstrumentationLibrarySpans().At(i)
 		for j := 0; j < ils.Spans().Len(); j++ {
 			span := ils.Spans().At(j)
-			if span.TraceID() == nil {
+			if span.TraceID().Bytes() == nil {
 				// this should have already been caught before our processor, but let's
 				// protect ourselves against bad clients
 				continue
 			}
 
-			sTraceID := span.TraceID().String()
+			sTraceID := span.TraceID().HexString()
 
 			// for the first traceID in the ILS, initialize the map entry
 			// and add the singleTraceBatch to the result list
diff --git a/processor/groupbytraceprocessor/processor_test.go b/processor/groupbytraceprocessor/processor_test.go
index 55cfb92df43..31a759fd4bb 100644
--- a/processor/groupbytraceprocessor/processor_test.go
+++ b/processor/groupbytraceprocessor/processor_test.go
@@ -28,6 +28,7 @@ import (
 
 	"go.opentelemetry.io/collector/component"
 	"go.opentelemetry.io/collector/consumer/pdata"
+	otlpcommon "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/trace/v1"
 )
 
@@ -40,7 +41,7 @@ func TestTraceIsDispatchedAfterDuration(t *testing.T) {
 	traces := []*v1.ResourceSpans{{
 		InstrumentationLibrarySpans: []*v1.InstrumentationLibrarySpans{{
 			Spans: []*v1.Span{{
-				TraceId: []byte{1, 2, 3, 4}, // no need to be 100% correct here
+				TraceId: otlpcommon.NewTraceID([]byte{1, 2, 3, 4}), // no need to be 100% correct here
 			}},
 		}},
 	}}
@@ -121,7 +122,7 @@ func TestInternalCacheLimit(t *testing.T) {
 	defer p.Shutdown(ctx)
 
 	// test
-	traceIDs := []pdata.TraceID{
+	traceIDs := [][]byte{
 		{1, 2, 3, 4},
 		{2, 3, 4, 5},
 		{3, 4, 5, 6},
@@ -135,7 +136,7 @@ func TestInternalCacheLimit(t *testing.T) {
 		batch := []*v1.ResourceSpans{{
 			InstrumentationLibrarySpans: []*v1.InstrumentationLibrarySpans{{
 				Spans: []*v1.Span{{
-					TraceId: traceID,
+					TraceId: otlpcommon.NewTraceID(traceID),
 				}},
 			}},
 		}}
@@ -150,7 +151,7 @@ func TestInternalCacheLimit(t *testing.T) {
 	assert.Equal(t, 5, len(receivedTraceIDs))
 
 	for i := 5; i > 0; i-- { // last 5 traces
-		traceID := traceIDs[i]
+		traceID := pdata.NewTraceID(traceIDs[i])
 		assert.Contains(t, receivedTraceIDs, traceID)
 	}
 
@@ -231,7 +232,7 @@ func TestTraceDisappearedFromStorageBeforeReleasing(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, p)
 
-	traceID := []byte{1, 2, 3, 4}
+	traceID := otlpcommon.NewTraceID([]byte{1, 2, 3, 4})
 	batch := []*v1.ResourceSpans{{
 		InstrumentationLibrarySpans: []*v1.InstrumentationLibrarySpans{{
 			Spans: []*v1.Span{{
@@ -249,7 +250,7 @@ func TestTraceDisappearedFromStorageBeforeReleasing(t *testing.T) {
 
 	// test
 	// we trigger this manually, instead of waiting the whole duration
-	err = p.markAsReleased(traceID)
+	err = p.markAsReleased(pdata.TraceID(traceID))
 
 	// verify
 	assert.Error(t, err)
@@ -273,7 +274,7 @@ func TestTraceErrorFromStorageWhileReleasing(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, p)
 
-	traceID := []byte{1, 2, 3, 4}
+	traceID := otlpcommon.NewTraceID([]byte{1, 2, 3, 4})
 	batch := []*v1.ResourceSpans{{
 		InstrumentationLibrarySpans: []*v1.InstrumentationLibrarySpans{{
 			Spans: []*v1.Span{{
@@ -291,7 +292,7 @@ func TestTraceErrorFromStorageWhileReleasing(t *testing.T) {
 
 	// test
 	// we trigger this manually, instead of waiting the whole duration
-	err = p.markAsReleased(traceID)
+	err = p.markAsReleased(pdata.TraceID(traceID))
 
 	// verify
 	assert.True(t, errors.Is(err, expectedError))
@@ -383,7 +384,7 @@ func TestAddSpansToExistingTrace(t *testing.T) {
 	p.Start(ctx, nil)
 	defer p.Shutdown(ctx)
 
-	traceID := []byte{1, 2, 3, 4}
+	traceID := otlpcommon.NewTraceID([]byte{1, 2, 3, 4})
 
 	// test
 	first := []*v1.ResourceSpans{{
@@ -474,7 +475,7 @@ func TestErrorFromStorageWhileRemovingTrace(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, p)
 
-	traceID := []byte{1, 2, 3, 4}
+	traceID := pdata.NewTraceID([]byte{1, 2, 3, 4})
 
 	// test
 	err = p.onTraceRemoved(traceID)
@@ -500,7 +501,7 @@ func TestTraceNotFoundWhileRemovingTrace(t *testing.T) {
 	require.NoError(t, err)
 	require.NotNil(t, p)
 
-	traceID := []byte{1, 2, 3, 4}
+	traceID := pdata.NewTraceID([]byte{1, 2, 3, 4})
 
 	// test
 	err = p.onTraceRemoved(traceID)
@@ -547,8 +548,7 @@ func TestTracesAreDispatchedInIndividualBatches(t *testing.T) {
 	span := ils.Spans().At(0)
 	span.SetTraceID(traceID)
 
-	secondTraceID := []byte{2, 3, 4, 5}
-
+	secondTraceID := pdata.NewTraceID([]byte{2, 3, 4, 5})
 	secondResourceSpans := pdata.NewResourceSpans()
 	secondResourceSpans.InitEmpty()
 	secondResourceSpans.InstrumentationLibrarySpans().Resize(1)
@@ -588,10 +588,10 @@ func TestSplitSameTraceIntoDifferentBatches(t *testing.T) {
 	firstILS.Spans().Resize(2)
 	firstSpan := firstILS.Spans().At(0)
 	firstSpan.SetName("first-batch-first-span")
-	firstSpan.SetTraceID([]byte{1, 2, 3, 4})
+	firstSpan.SetTraceID(pdata.NewTraceID([]byte{1, 2, 3, 4}))
 	secondSpan := firstILS.Spans().At(1)
 	secondSpan.SetName("first-batch-second-span")
-	secondSpan.SetTraceID([]byte{1, 2, 3, 4})
+	secondSpan.SetTraceID(pdata.NewTraceID([]byte{1, 2, 3, 4}))
 
 	// the second ILS has one span
 	secondILS := input.InstrumentationLibrarySpans().At(1)
@@ -601,7 +601,7 @@ func TestSplitSameTraceIntoDifferentBatches(t *testing.T) {
 	secondILS.Spans().Resize(1)
 	thirdSpan := secondILS.Spans().At(0)
 	thirdSpan.SetName("second-batch-first-span")
-	thirdSpan.SetTraceID([]byte{1, 2, 3, 4})
+	thirdSpan.SetTraceID(pdata.NewTraceID([]byte{1, 2, 3, 4}))
 
 	// test
 	batches := splitByTrace(input)
@@ -637,10 +637,10 @@ func TestSplitDifferentTracesIntoDifferentBatches(t *testing.T) {
 	ils.Spans().Resize(2)
 	firstSpan := ils.Spans().At(0)
 	firstSpan.SetName("first-batch-first-span")
-	firstSpan.SetTraceID([]byte{1, 2, 3, 4})
+	firstSpan.SetTraceID(pdata.NewTraceID([]byte{1, 2, 3, 4}))
 	secondSpan := ils.Spans().At(1)
 	secondSpan.SetName("first-batch-second-span")
-	secondSpan.SetTraceID([]byte{2, 3, 4, 5})
+	secondSpan.SetTraceID(pdata.NewTraceID([]byte{2, 3, 4, 5}))
 
 	// test
 	batches := splitByTrace(input)
@@ -667,7 +667,7 @@ func TestSplitByTraceWithNilTraceID(t *testing.T) {
 	ils := input.InstrumentationLibrarySpans().At(0)
 	ils.Spans().Resize(1)
 	firstSpan := ils.Spans().At(0)
-	firstSpan.SetTraceID(nil)
+	firstSpan.SetTraceID(pdata.NewTraceID(nil))
 
 	// test
 	batches := splitByTrace(input)
@@ -733,7 +733,7 @@ func BenchmarkConsumeTracesCompleteOnFirstBatch(b *testing.B) {
 	defer p.Shutdown(ctx)
 
 	for n := 0; n < b.N; n++ {
-		traceID := []byte{byte(1 + n), 2, 3, 4}
+		traceID := otlpcommon.NewTraceID([]byte{byte(1 + n), 2, 3, 4})
 		trace := []*v1.ResourceSpans{{
 			InstrumentationLibrarySpans: []*v1.InstrumentationLibrarySpans{{
 				Spans: []*v1.Span{{
diff --git a/processor/groupbytraceprocessor/ring_buffer.go b/processor/groupbytraceprocessor/ring_buffer.go
index bed3f283ca5..d0928a44650 100644
--- a/processor/groupbytraceprocessor/ring_buffer.go
+++ b/processor/groupbytraceprocessor/ring_buffer.go
@@ -40,31 +40,31 @@ func (r *ringBuffer) put(traceID pdata.TraceID) pdata.TraceID {
 	// see if the ring has an item already
 	evicted := r.ids[r.index]
 
-	if evicted != nil {
+	if evicted.Bytes() != nil {
 		// clear space for the new item
 		r.delete(evicted)
 	}
 
 	// place the traceID in memory
 	r.ids[r.index] = traceID
-	r.idToIndex[traceID.String()] = r.index
+	r.idToIndex[traceID.HexString()] = r.index
 
 	return evicted
 }
 
 func (r *ringBuffer) contains(traceID pdata.TraceID) bool {
-	_, found := r.idToIndex[traceID.String()]
+	_, found := r.idToIndex[traceID.HexString()]
 	return found
 }
 
 func (r *ringBuffer) delete(traceID pdata.TraceID) bool {
-	sTraceID := traceID.String()
+	sTraceID := traceID.HexString()
 	index, found := r.idToIndex[sTraceID]
 	if !found {
 		return false
 	}
 
 	delete(r.idToIndex, sTraceID)
-	r.ids[index] = nil
+	r.ids[index] = pdata.NewTraceID(nil)
 	return true
 }
diff --git a/processor/groupbytraceprocessor/ring_buffer_test.go b/processor/groupbytraceprocessor/ring_buffer_test.go
index cc4c53de481..ee92fffc0bd 100644
--- a/processor/groupbytraceprocessor/ring_buffer_test.go
+++ b/processor/groupbytraceprocessor/ring_buffer_test.go
@@ -28,12 +28,12 @@ func TestRingBufferCapacity(t *testing.T) {
 
 	// test
 	traceIDs := []pdata.TraceID{
-		{1, 2, 3, 4},
-		{2, 3, 4, 5},
-		{3, 4, 5, 6},
-		{4, 5, 6, 7},
-		{5, 6, 7, 8},
-		{6, 7, 8, 9},
+		pdata.NewTraceID([]byte{1, 2, 3, 4}),
+		pdata.NewTraceID([]byte{2, 3, 4, 5}),
+		pdata.NewTraceID([]byte{3, 4, 5, 6}),
+		pdata.NewTraceID([]byte{4, 5, 6, 7}),
+		pdata.NewTraceID([]byte{5, 6, 7, 8}),
+		pdata.NewTraceID([]byte{6, 7, 8, 9}),
 	}
 	for _, traceID := range traceIDs {
 		buffer.put(traceID)
diff --git a/processor/groupbytraceprocessor/storage_memory.go b/processor/groupbytraceprocessor/storage_memory.go
index 9c7872b1ee3..8012198f90b 100644
--- a/processor/groupbytraceprocessor/storage_memory.go
+++ b/processor/groupbytraceprocessor/storage_memory.go
@@ -41,7 +41,7 @@ func (st *memoryStorage) createOrAppend(traceID pdata.TraceID, rs pdata.Resource
 		return errStorageNilResourceSpans
 	}
 
-	sTraceID := traceID.String()
+	sTraceID := traceID.HexString()
 
 	st.Lock()
 	if _, ok := st.content[sTraceID]; !ok {
@@ -57,7 +57,7 @@ func (st *memoryStorage) createOrAppend(traceID pdata.TraceID, rs pdata.Resource
 	return nil
 }
 func (st *memoryStorage) get(traceID pdata.TraceID) ([]pdata.ResourceSpans, error) {
-	sTraceID := traceID.String()
+	sTraceID := traceID.HexString()
 
 	st.RLock()
 	rss, ok := st.content[sTraceID]
@@ -79,7 +79,7 @@ func (st *memoryStorage) get(traceID pdata.TraceID) ([]pdata.ResourceSpans, erro
 // delete will return a reference to a ResourceSpans. Changes to the returned object may not be applied
 // to the version in the storage.
 func (st *memoryStorage) delete(traceID pdata.TraceID) ([]pdata.ResourceSpans, error) {
-	sTraceID := traceID.String()
+	sTraceID := traceID.HexString()
 
 	st.Lock()
 	rss := st.content[sTraceID]
diff --git a/processor/groupbytraceprocessor/storage_memory_test.go b/processor/groupbytraceprocessor/storage_memory_test.go
index 12a6d6bd286..a3202dcfa3a 100644
--- a/processor/groupbytraceprocessor/storage_memory_test.go
+++ b/processor/groupbytraceprocessor/storage_memory_test.go
@@ -27,9 +27,9 @@ func TestMemoryCreateAndGetTrace(t *testing.T) {
 	// prepare
 	st := newMemoryStorage()
 
-	traceIDs := [][]byte{
-		{1, 2, 3, 4},
-		{2, 3, 4, 5},
+	traceIDs := []pdata.TraceID{
+		pdata.NewTraceID([]byte{1, 2, 3, 4}),
+		pdata.NewTraceID([]byte{2, 3, 4, 5}),
 	}
 
 	baseTrace := pdata.NewResourceSpans()
@@ -41,7 +41,7 @@ func TestMemoryCreateAndGetTrace(t *testing.T) {
 
 	// test
 	for _, traceID := range traceIDs {
-		span.SetTraceID(pdata.NewTraceID(traceID))
+		span.SetTraceID(traceID)
 		st.createOrAppend(traceID, baseTrace)
 	}
 
@@ -171,7 +171,7 @@ func TestMemoryTraceIsBeingCloned(t *testing.T) {
 func TestCreateWithNilParameter(t *testing.T) {
 	// prepare
 	st := newMemoryStorage()
-	traceID := []byte{1, 2, 3, 4}
+	traceID := pdata.NewTraceID([]byte{1, 2, 3, 4})
 
 	// test
 	err := st.createOrAppend(traceID, pdata.NewResourceSpans())
diff --git a/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler.go b/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler.go
index cd6cd89ee7f..07c99da666a 100644
--- a/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler.go
+++ b/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler.go
@@ -112,7 +112,7 @@ func (tsp *tracesamplerprocessor) processTraces(ctx context.Context, resourceSpa
 			// with various different criteria to generate trace id and perhaps were already sampled without hashing.
 			// Hashing here prevents bias due to such systems.
 			sampled := sp == mustSampleSpan ||
-				hash(span.TraceID(), tsp.hashSeed)&bitMaskHashBuckets < scaledSamplingRate
+				hash(span.TraceID().Bytes(), tsp.hashSeed)&bitMaskHashBuckets < scaledSamplingRate
 
 			if sampled {
 				spns.Append(span)
diff --git a/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler_test.go b/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler_test.go
index a84cc592dba..a095d7e32c2 100644
--- a/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler_test.go
+++ b/processor/samplingprocessor/probabilisticsamplerprocessor/probabilisticsampler_test.go
@@ -464,7 +464,7 @@ func genRandomTestData(numBatches, numTracesPerBatch int, serviceName string, re
 
 			for k := 0; k < numTracesPerBatch; k++ {
 				span := ils.Spans().At(k)
-				span.SetTraceID(tracetranslator.UInt64ToByteTraceID(r.Uint64(), r.Uint64()))
+				span.SetTraceID(tracetranslator.UInt64ToTraceID(r.Uint64(), r.Uint64()))
 				span.SetSpanID(tracetranslator.UInt64ToByteSpanID(r.Uint64()))
 				attributes := make(map[string]pdata.AttributeValue)
 				attributes[tracetranslator.TagHTTPStatusCode] = pdata.NewAttributeValueInt(404)
@@ -502,7 +502,7 @@ func assertSampledData(t *testing.T, sampled []pdata.Traces, serviceName string)
 				for k := 0; k < ils.Spans().Len(); k++ {
 					spanCount++
 					span := ils.Spans().At(k)
-					key := string(span.TraceID())
+					key := string(span.TraceID().Bytes())
 					if traceIDs[key] {
 						t.Errorf("same traceID used more than once %q", key)
 						return
diff --git a/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher.go b/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher.go
index 2bfac74607b..d18baaaa264 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher.go
@@ -19,6 +19,8 @@ package idbatcher
 import (
 	"errors"
 	"sync"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 var (
@@ -28,11 +30,8 @@ var (
 	ErrInvalidBatchChannelSize = errors.New("invalid batch channel size, it must be greater than zero")
 )
 
-// ID is the type of each element in the batch.
-type ID []byte
-
 // Batch is the type of batches held by the Batcher.
-type Batch []ID
+type Batch []pdata.TraceID
 
 // Batcher behaves like a pipeline of batches that has a fixed number of batches in the pipe
 // and a new batch being built outside of the pipe. Items can be concurrently added to the batch
@@ -45,7 +44,7 @@ type Batcher interface {
 	// of limiting the growth of the current batch if appropriate for its scenario. It can
 	// either call CloseCurrentAndTakeFirstBatch earlier or stop adding new items depending on what is
 	// required by the scenario.
-	AddToCurrentBatch(id ID)
+	AddToCurrentBatch(id pdata.TraceID)
 	// CloseCurrentAndTakeFirstBatch takes the batch at the front of the pipe, and moves the current
 	// batch to the end of the pipe, creating a new batch to receive new items. This operation should
 	// be atomic.
@@ -60,8 +59,8 @@ type Batcher interface {
 var _ Batcher = (*batcher)(nil)
 
 type batcher struct {
-	pendingIds chan ID    // Channel for the ids to be added to the next batch.
-	batches    chan Batch // Channel with already captured batches.
+	pendingIds chan pdata.TraceID // Channel for the ids to be added to the next batch.
+	batches    chan Batch         // Channel with already captured batches.
 
 	// cbMutex protects the currentBatch storing ids.
 	cbMutex      sync.Mutex
@@ -93,7 +92,7 @@ func New(numBatches, newBatchesInitialCapacity, batchChannelSize uint64) (Batche
 	}
 
 	batcher := &batcher{
-		pendingIds:                make(chan ID, batchChannelSize),
+		pendingIds:                make(chan pdata.TraceID, batchChannelSize),
 		batches:                   batches,
 		currentBatch:              make(Batch, 0, newBatchesInitialCapacity),
 		newBatchesInitialCapacity: newBatchesInitialCapacity,
@@ -114,7 +113,7 @@ func New(numBatches, newBatchesInitialCapacity, batchChannelSize uint64) (Batche
 	return batcher, nil
 }
 
-func (b *batcher) AddToCurrentBatch(id ID) {
+func (b *batcher) AddToCurrentBatch(id pdata.TraceID) {
 	b.pendingIds <- id
 }
 
diff --git a/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher_test.go b/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher_test.go
index ef49f89d022..d1c73dabd58 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher_test.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/idbatcher/id_batcher_test.go
@@ -23,6 +23,7 @@ import (
 
 	"github.com/stretchr/testify/require"
 
+	"go.opentelemetry.io/collector/consumer/pdata"
 	tracetranslator "go.opentelemetry.io/collector/translator/trace"
 )
 
@@ -119,7 +120,7 @@ func concurrencyTest(t *testing.T, numBatches, newBatchesInitialCapacity, batchC
 	wg := &sync.WaitGroup{}
 	for i := 0; i < len(ids); i++ {
 		wg.Add(1)
-		go func(id []byte) {
+		go func(id pdata.TraceID) {
 			batcher.AddToCurrentBatch(id)
 			wg.Done()
 		}(ids[i])
@@ -143,18 +144,18 @@ func concurrencyTest(t *testing.T, numBatches, newBatchesInitialCapacity, batchC
 
 	idSeen := make(map[string]bool, len(ids))
 	for _, id := range got {
-		idSeen[string(id)] = true
+		idSeen[string(id.Bytes())] = true
 	}
 
 	for i := 0; i < len(ids); i++ {
-		require.True(t, idSeen[string(ids[i])], "want id %v but id was not seen", ids[i])
+		require.True(t, idSeen[string(ids[i].Bytes())], "want id %v but id was not seen", ids[i])
 	}
 }
 
-func generateSequentialIds(numIds uint64) [][]byte {
-	ids := make([][]byte, numIds)
+func generateSequentialIds(numIds uint64) []pdata.TraceID {
+	ids := make([]pdata.TraceID, numIds)
 	for i := uint64(0); i < numIds; i++ {
-		ids[i] = tracetranslator.UInt64ToByteTraceID(0, i)
+		ids[i] = tracetranslator.UInt64ToTraceID(0, i)
 	}
 	return ids
 }
diff --git a/processor/samplingprocessor/tailsamplingprocessor/processor.go b/processor/samplingprocessor/tailsamplingprocessor/processor.go
index 1bf12c393f5..3301922f286 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/processor.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/processor.go
@@ -145,7 +145,7 @@ func (tsp *tailSamplingSpanProcessor) samplingPolicyOnTick() {
 	batchLen := len(batch)
 	tsp.logger.Debug("Sampling Policy Evaluation ticked")
 	for _, id := range batch {
-		d, ok := tsp.idToTrace.Load(traceKey(id))
+		d, ok := tsp.idToTrace.Load(traceKey(id.Bytes()))
 		if !ok {
 			idNotFoundOnMapCount++
 			continue
@@ -265,7 +265,7 @@ func (tsp *tailSamplingSpanProcessor) processTraces(td consumerdata.TraceData) e
 			atomic.AddInt64(&actualData.SpanCount, lenSpans)
 		} else {
 			newTraceIDs++
-			tsp.decisionBatcher.AddToCurrentBatch([]byte(id))
+			tsp.decisionBatcher.AddToCurrentBatch(pdata.NewTraceID([]byte(id)))
 			atomic.AddUint64(&tsp.numTracesOnMap, 1)
 			postDeletion := false
 			currTime := time.Now()
@@ -354,7 +354,7 @@ func (tsp *tailSamplingSpanProcessor) dropTrace(traceID traceKey, deletionTime t
 	for j := 0; j < policiesLen; j++ {
 		if trace.Decisions[j] == sampling.Pending {
 			policy := tsp.policies[j]
-			if decision, err := policy.Evaluator.OnDroppedSpans([]byte(traceID), trace); err != nil {
+			if decision, err := policy.Evaluator.OnDroppedSpans(pdata.NewTraceID([]byte(traceID)), trace); err != nil {
 				tsp.logger.Warn("OnDroppedSpans",
 					zap.String("policy", policy.Name),
 					zap.Int("decision", int(decision)),
diff --git a/processor/samplingprocessor/tailsamplingprocessor/processor_test.go b/processor/samplingprocessor/tailsamplingprocessor/processor_test.go
index dbbfa5b3a8f..aa98cd1f0a2 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/processor_test.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/processor_test.go
@@ -53,7 +53,7 @@ func TestSequentialTraceArrival(t *testing.T) {
 	}
 
 	for i := range traceIds {
-		d, ok := tsp.idToTrace.Load(traceKey(traceIds[i]))
+		d, ok := tsp.idToTrace.Load(traceKey(traceIds[i].Bytes()))
 		require.True(t, ok, "Missing expected traceId")
 		v := d.(*sampling.TraceData)
 		require.Equal(t, int64(i+1), v.SpanCount, "Incorrect number of spans for entry %d", i)
@@ -88,7 +88,7 @@ func TestConcurrentTraceArrival(t *testing.T) {
 	wg.Wait()
 
 	for i := range traceIds {
-		d, ok := tsp.idToTrace.Load(traceKey(traceIds[i]))
+		d, ok := tsp.idToTrace.Load(traceKey(traceIds[i].Bytes()))
 		require.True(t, ok, "Missing expected traceId")
 		v := d.(*sampling.TraceData)
 		require.Equal(t, int64(i+1)*2, v.SpanCount, "Incorrect number of spans for entry %d", i)
@@ -112,7 +112,7 @@ func TestSequentialTraceMapSize(t *testing.T) {
 
 	// On sequential insertion it is possible to know exactly which traces should be still on the map.
 	for i := 0; i < len(traceIds)-maxSize; i++ {
-		_, ok := tsp.idToTrace.Load(traceKey(traceIds[i]))
+		_, ok := tsp.idToTrace.Load(traceKey(traceIds[i].Bytes()))
 		require.False(t, ok, "Found unexpected traceId[%d] still on map (id: %v)", i, traceIds[i])
 	}
 }
@@ -205,11 +205,11 @@ func TestSamplingPolicyTypicalPath(t *testing.T) {
 	require.Equal(t, 1, mpe.LateArrivingSpansCount, "policy was not notified of the late span")
 }
 
-func generateIdsAndBatches(numIds int) ([][]byte, []pdata.Traces) {
-	traceIds := make([][]byte, numIds)
+func generateIdsAndBatches(numIds int) ([]pdata.TraceID, []pdata.Traces) {
+	traceIds := make([]pdata.TraceID, numIds)
 	var tds []pdata.Traces
 	for i := 0; i < numIds; i++ {
-		traceIds[i] = tracetranslator.UInt64ToByteTraceID(1, uint64(i+1))
+		traceIds[i] = tracetranslator.UInt64ToTraceID(1, uint64(i+1))
 		// Send each span in a separate batch
 		for j := 0; j <= i; j++ {
 			td := testdata.GenerateTraceDataOneSpan()
@@ -237,11 +237,11 @@ func (m *mockPolicyEvaluator) OnLateArrivingSpans(sampling.Decision, []*tracepb.
 	m.LateArrivingSpansCount++
 	return m.NextError
 }
-func (m *mockPolicyEvaluator) Evaluate([]byte, *sampling.TraceData) (sampling.Decision, error) {
+func (m *mockPolicyEvaluator) Evaluate(pdata.TraceID, *sampling.TraceData) (sampling.Decision, error) {
 	m.EvaluationCount++
 	return m.NextDecision, m.NextError
 }
-func (m *mockPolicyEvaluator) OnDroppedSpans([]byte, *sampling.TraceData) (sampling.Decision, error) {
+func (m *mockPolicyEvaluator) OnDroppedSpans(pdata.TraceID, *sampling.TraceData) (sampling.Decision, error) {
 	m.OnDroppedSpansCount++
 	return m.NextDecision, m.NextError
 }
@@ -280,7 +280,7 @@ func newSyncIDBatcher(numBatches uint64) idbatcher.Batcher {
 	}
 }
 
-func (s *syncIDBatcher) AddToCurrentBatch(id idbatcher.ID) {
+func (s *syncIDBatcher) AddToCurrentBatch(id pdata.TraceID) {
 	s.Lock()
 	s.openBatch = append(s.openBatch, id)
 	s.Unlock()
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/always_sample.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/always_sample.go
index c624854a30e..d81663ce385 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/always_sample.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/always_sample.go
@@ -17,6 +17,8 @@ package sampling
 import (
 	tracepb "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
 	"go.uber.org/zap"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 type alwaysSample struct {
@@ -42,14 +44,14 @@ func (as *alwaysSample) OnLateArrivingSpans(Decision, []*tracepb.Span) error {
 }
 
 // Evaluate looks at the trace data and returns a corresponding SamplingDecision.
-func (as *alwaysSample) Evaluate([]byte, *TraceData) (Decision, error) {
+func (as *alwaysSample) Evaluate(pdata.TraceID, *TraceData) (Decision, error) {
 	as.logger.Debug("Evaluating spans in always-sample filter")
 	return Sampled, nil
 }
 
 // OnDroppedSpans is called when the trace needs to be dropped, due to memory
 // pressure, before the decision_wait time has been reached.
-func (as *alwaysSample) OnDroppedSpans([]byte, *TraceData) (Decision, error) {
+func (as *alwaysSample) OnDroppedSpans(pdata.TraceID, *TraceData) (Decision, error) {
 	as.logger.Debug("Triggering action for dropped spans in always-sample filter")
 	return Sampled, nil
 }
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter.go
index 9b883a2ed7b..25e1fda8c3b 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter.go
@@ -17,6 +17,8 @@ package sampling
 import (
 	tracepb "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
 	"go.uber.org/zap"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 type numericAttributeFilter struct {
@@ -48,7 +50,7 @@ func (naf *numericAttributeFilter) OnLateArrivingSpans(Decision, []*tracepb.Span
 }
 
 // Evaluate looks at the trace data and returns a corresponding SamplingDecision.
-func (naf *numericAttributeFilter) Evaluate(_ []byte, trace *TraceData) (Decision, error) {
+func (naf *numericAttributeFilter) Evaluate(_ pdata.TraceID, trace *TraceData) (Decision, error) {
 	naf.logger.Debug("Evaluating spans in numeric-attribute filter")
 	trace.Lock()
 	batches := trace.ReceivedBatches
@@ -72,7 +74,7 @@ func (naf *numericAttributeFilter) Evaluate(_ []byte, trace *TraceData) (Decisio
 
 // OnDroppedSpans is called when the trace needs to be dropped, due to memory
 // pressure, before the decision_wait time has been reached.
-func (naf *numericAttributeFilter) OnDroppedSpans([]byte, *TraceData) (Decision, error) {
+func (naf *numericAttributeFilter) OnDroppedSpans(pdata.TraceID, *TraceData) (Decision, error) {
 	naf.logger.Debug("Triggering action for dropped spans in numeric-attribute filter")
 	return NotSampled, nil
 }
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter_test.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter_test.go
index 968db11e799..e8bd9fc9aed 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter_test.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/numeric_tag_filter_test.go
@@ -24,6 +24,7 @@ import (
 	"go.uber.org/zap"
 
 	"go.opentelemetry.io/collector/consumer/consumerdata"
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 func TestNumericTagFilter(t *testing.T) {
@@ -65,7 +66,7 @@ func TestNumericTagFilter(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.Desc, func(t *testing.T) {
 			u, _ := uuid.NewRandom()
-			decision, err := filter.Evaluate(u[:], c.Trace)
+			decision, err := filter.Evaluate(pdata.NewTraceID(u[:]), c.Trace)
 			assert.NoError(t, err)
 			assert.Equal(t, decision, c.Decision)
 		})
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/policy.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/policy.go
index 29711de1aee..a3a4e66c27a 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/policy.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/policy.go
@@ -21,6 +21,7 @@ import (
 	tracepb "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
 
 	"go.opentelemetry.io/collector/consumer/consumerdata"
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 // TraceData stores the sampling related trace data.
@@ -67,9 +68,9 @@ type PolicyEvaluator interface {
 	OnLateArrivingSpans(earlyDecision Decision, spans []*tracepb.Span) error
 
 	// Evaluate looks at the trace data and returns a corresponding SamplingDecision.
-	Evaluate(traceID []byte, trace *TraceData) (Decision, error)
+	Evaluate(traceID pdata.TraceID, trace *TraceData) (Decision, error)
 
 	// OnDroppedSpans is called when the trace needs to be dropped, due to memory
 	// pressure, before the decision_wait time has been reached.
-	OnDroppedSpans(traceID []byte, trace *TraceData) (Decision, error)
+	OnDroppedSpans(traceID pdata.TraceID, trace *TraceData) (Decision, error)
 }
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/rate_limiting.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/rate_limiting.go
index 0397870992d..fa5918e6448 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/rate_limiting.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/rate_limiting.go
@@ -19,6 +19,8 @@ import (
 
 	tracepb "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
 	"go.uber.org/zap"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 type rateLimiting struct {
@@ -48,7 +50,7 @@ func (r *rateLimiting) OnLateArrivingSpans(Decision, []*tracepb.Span) error {
 }
 
 // Evaluate looks at the trace data and returns a corresponding SamplingDecision.
-func (r *rateLimiting) Evaluate(_ []byte, trace *TraceData) (Decision, error) {
+func (r *rateLimiting) Evaluate(_ pdata.TraceID, trace *TraceData) (Decision, error) {
 	r.logger.Debug("Evaluating spans in rate-limiting filter")
 	currSecond := time.Now().Unix()
 	if r.currentSecond != currSecond {
@@ -67,7 +69,7 @@ func (r *rateLimiting) Evaluate(_ []byte, trace *TraceData) (Decision, error) {
 
 // OnDroppedSpans is called when the trace needs to be dropped, due to memory
 // pressure, before the decision_wait time has been reached.
-func (r *rateLimiting) OnDroppedSpans([]byte, *TraceData) (Decision, error) {
+func (r *rateLimiting) OnDroppedSpans(pdata.TraceID, *TraceData) (Decision, error) {
 	r.logger.Debug("Triggering action for dropped spans in rate-limiting filter")
 	return Sampled, nil
 }
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter.go
index accea48a6fc..d8bc23ea254 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter.go
@@ -17,6 +17,8 @@ package sampling
 import (
 	tracepb "github.com/census-instrumentation/opencensus-proto/gen-go/trace/v1"
 	"go.uber.org/zap"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 type stringAttributeFilter struct {
@@ -53,7 +55,7 @@ func (saf *stringAttributeFilter) OnLateArrivingSpans(Decision, []*tracepb.Span)
 }
 
 // Evaluate looks at the trace data and returns a corresponding SamplingDecision.
-func (saf *stringAttributeFilter) Evaluate(_ []byte, trace *TraceData) (Decision, error) {
+func (saf *stringAttributeFilter) Evaluate(_ pdata.TraceID, trace *TraceData) (Decision, error) {
 	saf.logger.Debug("Evaluting spans in string-tag filter")
 	trace.Lock()
 	batches := trace.ReceivedBatches
@@ -87,7 +89,7 @@ func (saf *stringAttributeFilter) Evaluate(_ []byte, trace *TraceData) (Decision
 
 // OnDroppedSpans is called when the trace needs to be dropped, due to memory
 // pressure, before the decision_wait time has been reached.
-func (saf *stringAttributeFilter) OnDroppedSpans([]byte, *TraceData) (Decision, error) {
+func (saf *stringAttributeFilter) OnDroppedSpans(pdata.TraceID, *TraceData) (Decision, error) {
 	saf.logger.Debug("Triggering action for dropped spans in string-tag filter")
 	return NotSampled, nil
 }
diff --git a/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter_test.go b/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter_test.go
index 6abc57eec36..2b9f5183dfb 100644
--- a/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter_test.go
+++ b/processor/samplingprocessor/tailsamplingprocessor/sampling/string_tag_filter_test.go
@@ -24,6 +24,7 @@ import (
 	"go.uber.org/zap"
 
 	"go.opentelemetry.io/collector/consumer/consumerdata"
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 func TestStringTagFilter(t *testing.T) {
@@ -71,7 +72,7 @@ func TestStringTagFilter(t *testing.T) {
 	for _, c := range cases {
 		t.Run(c.Desc, func(t *testing.T) {
 			u, _ := uuid.NewRandom()
-			decision, err := filter.Evaluate(u[:], c.Trace)
+			decision, err := filter.Evaluate(pdata.NewTraceID(u[:]), c.Trace)
 			assert.NoError(t, err)
 			assert.Equal(t, decision, c.Decision)
 		})
diff --git a/proto_patch.sed b/proto_patch.sed
index 9ab872bb612..b465d738e87 100644
--- a/proto_patch.sed
+++ b/proto_patch.sed
@@ -3,3 +3,11 @@ s+github.com/open-telemetry/opentelemetry-proto/gen/go/+go.opentelemetry.io/coll
 s+package opentelemetry.proto.\(.*\).v1;+package opentelemetry.proto.\1.v1;\
 \
 import "github.com/gogo/protobuf@v1.3.1/gogoproto/gogo.proto";+g
+
+s+bytes trace_id = \(.*\);+bytes trace_id = \1\
+  [\
+  // Use custom TraceId data type for this field.\
+  (gogoproto.nullable) = false,\
+  (gogoproto.customtype) = "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1.TraceID",\
+  (gogoproto.customname) = "TraceId"\
+  ];+g
diff --git a/receiver/jaegerreceiver/jaeger_agent_test.go b/receiver/jaegerreceiver/jaeger_agent_test.go
index 2f7c975eb42..bde2d9517b4 100644
--- a/receiver/jaegerreceiver/jaeger_agent_test.go
+++ b/receiver/jaegerreceiver/jaeger_agent_test.go
@@ -242,7 +242,7 @@ func generateTraceData() pdata.Traces {
 	td.ResourceSpans().At(0).InstrumentationLibrarySpans().At(0).Spans().Resize(1)
 	span := td.ResourceSpans().At(0).InstrumentationLibrarySpans().At(0).Spans().At(0)
 	span.SetSpanID([]byte{0, 1, 2, 3, 4, 5, 6, 7})
-	span.SetTraceID([]byte{0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0})
+	span.SetTraceID(pdata.NewTraceID([]byte{0, 1, 2, 3, 4, 5, 6, 7, 7, 6, 5, 4, 3, 2, 1, 0}))
 	span.SetStartTime(1581452772000000000)
 	span.SetEndTime(1581452773000000000)
 	return td
diff --git a/receiver/jaegerreceiver/trace_receiver_test.go b/receiver/jaegerreceiver/trace_receiver_test.go
index 2719eafbc05..ca5c144d66b 100644
--- a/receiver/jaegerreceiver/trace_receiver_test.go
+++ b/receiver/jaegerreceiver/trace_receiver_test.go
@@ -297,7 +297,7 @@ func TestGRPCReceptionWithTLS(t *testing.T) {
 }
 
 func expectedTraceData(t1, t2, t3 time.Time) pdata.Traces {
-	traceID := pdata.TraceID(
+	traceID := pdata.NewTraceID(
 		[]byte{0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x80})
 	parentSpanID := pdata.SpanID([]byte{0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x19, 0x18})
 	childSpanID := pdata.SpanID([]byte{0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8})
diff --git a/receiver/otlpreceiver/logs/otlp_test.go b/receiver/otlpreceiver/logs/otlp_test.go
index 43340b744b9..c670a03cce4 100644
--- a/receiver/otlpreceiver/logs/otlp_test.go
+++ b/receiver/otlpreceiver/logs/otlp_test.go
@@ -30,6 +30,7 @@ import (
 	"go.opentelemetry.io/collector/exporter/exportertest"
 	"go.opentelemetry.io/collector/internal"
 	collectorlog "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/collector/logs/v1"
+	v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	otlplog "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/logs/v1"
 	"go.opentelemetry.io/collector/obsreport"
 	"go.opentelemetry.io/collector/testutil"
@@ -65,7 +66,7 @@ func TestExport(t *testing.T) {
 				{
 					Logs: []*otlplog.LogRecord{
 						{
-							TraceId:      traceID,
+							TraceId:      v1.NewTraceID(traceID),
 							SpanId:       spanID,
 							Name:         "operationB",
 							TimeUnixNano: unixnanos,
diff --git a/receiver/otlpreceiver/marshal_jsonpb_test.go b/receiver/otlpreceiver/marshal_jsonpb_test.go
index 5e5d25d57b1..8d151043dc1 100644
--- a/receiver/otlpreceiver/marshal_jsonpb_test.go
+++ b/receiver/otlpreceiver/marshal_jsonpb_test.go
@@ -39,6 +39,7 @@ const expectedJSON = `{
     {
       "spans": [
         {
+          "traceId": "",
           "name": "operationA",
           "startTimeUnixNano": "1581452772000000321",
           "endTimeUnixNano": "1581452773000000789",
diff --git a/receiver/otlpreceiver/otlp_test.go b/receiver/otlpreceiver/otlp_test.go
index 5b647ab1562..af954f0a6ae 100644
--- a/receiver/otlpreceiver/otlp_test.go
+++ b/receiver/otlpreceiver/otlp_test.go
@@ -27,7 +27,7 @@ import (
 	"testing"
 	"time"
 
-	gogoproto "github.com/gogo/protobuf/proto"
+	"github.com/gogo/protobuf/jsonpb"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	spb "google.golang.org/genproto/googleapis/rpc/status"
@@ -58,6 +58,74 @@ import (
 
 const otlpReceiverName = "otlp_receiver_test"
 
+var traceJSON = []byte(`
+	{
+	  "resource_spans": [
+		{
+		  "resource": {
+			"attributes": [
+			  {
+				"key": "host.hostname",
+				"value": { "stringValue": "testHost" }
+			  }
+			]
+		  },
+		  "instrumentation_library_spans": [
+			{
+			  "spans": [
+				{
+				  "trace_id": "5B8EFFF798038103D269B633813FC60C",
+				  "span_id": "7uGbfsPBsXM=",
+				  "name": "testSpan",
+				  "start_time_unix_nano": 1544712660000000000,
+				  "end_time_unix_nano": 1544712661000000000,
+				  "attributes": [
+					{
+					  "key": "attr1",
+					  "value": { "intValue": 55 }
+					}
+				  ]
+				}
+			  ]
+			}
+		  ]
+		}
+	  ]
+	}`)
+
+var resourceSpansOtlp = otlptrace.ResourceSpans{
+
+	Resource: &otlpresource.Resource{
+		Attributes: []*otlpcommon.KeyValue{
+			{
+				Key:   conventions.AttributeHostHostname,
+				Value: &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "testHost"}},
+			},
+		},
+	},
+	InstrumentationLibrarySpans: []*otlptrace.InstrumentationLibrarySpans{
+		{
+			Spans: []*otlptrace.Span{
+				{
+					TraceId:           otlpcommon.NewTraceID([]byte{0x5B, 0x8E, 0xFF, 0xF7, 0x98, 0x3, 0x81, 0x3, 0xD2, 0x69, 0xB6, 0x33, 0x81, 0x3F, 0xC6, 0xC}),
+					SpanId:            []byte{0xEE, 0xE1, 0x9B, 0x7E, 0xC3, 0xC1, 0xB1, 0x73},
+					Name:              "testSpan",
+					StartTimeUnixNano: 1544712660000000000,
+					EndTimeUnixNano:   1544712661000000000,
+					Attributes: []*otlpcommon.KeyValue{
+						{
+							Key:   "attr1",
+							Value: &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_IntValue{IntValue: 55}},
+						},
+					},
+				},
+			},
+		},
+	},
+}
+
+var traceOtlp = pdata.TracesFromOtlp([]*otlptrace.ResourceSpans{&resourceSpansOtlp})
+
 func TestJsonHttp(t *testing.T) {
 	tests := []struct {
 		name     string
@@ -98,40 +166,6 @@ func TestJsonHttp(t *testing.T) {
 
 	url := fmt.Sprintf("http://%s/v1/trace", addr)
 
-	traceJSON := []byte(`
-	{
-	  "resource_spans": [
-		{
-		  "resource": {
-			"attributes": [
-			  {
-				"key": "host.hostname",
-				"value": { "stringValue": "testHost" }
-			  }
-			]
-		  },
-		  "instrumentation_library_spans": [
-			{
-			  "spans": [
-				{
-				  "trace_id": "W47/95gDgQPSabYzgT/GDA==",
-				  "span_id": "7uGbfsPBsXM=",
-				  "name": "testSpan",
-				  "start_time_unix_nano": 1544712660000000000,
-				  "end_time_unix_nano": 1544712661000000000,
-				  "attributes": [
-					{
-					  "key": "attr1",
-					  "value": { "intValue": 55 }
-					}
-				  ]
-				}
-			  ]
-			}
-		  ]
-		}
-	  ]
-	}`)
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			var buf *bytes.Buffer
@@ -158,7 +192,6 @@ func TestJsonHttp(t *testing.T) {
 				t.Errorf("Error reading response from trace grpc-gateway, %v", err)
 			}
 			respStr := string(respBytes)
-
 			err = resp.Body.Close()
 			if err != nil {
 				t.Errorf("Error closing response body, %v", err)
@@ -182,39 +215,74 @@ func TestJsonHttp(t *testing.T) {
 			}
 
 			got := sink.AllTraces()[0]
+			assert.EqualValues(t, got, traceOtlp)
+		})
+	}
+}
+
+func TestJsonMarshaling(t *testing.T) {
+	m := jsonpb.Marshaler{}
+	json, err := m.MarshalToString(&resourceSpansOtlp)
+	assert.NoError(t, err)
+
+	var resourceSpansOtlp2 otlptrace.ResourceSpans
+	err = jsonpb.UnmarshalString(json, &resourceSpansOtlp2)
+	assert.NoError(t, err)
+
+	assert.EqualValues(t, resourceSpansOtlp, resourceSpansOtlp2)
+}
 
-			want := pdata.TracesFromOtlp([]*otlptrace.ResourceSpans{
+func TestJsonUnmarshaling(t *testing.T) {
+	var resourceSpansOtlp2 otlptrace.ResourceSpans
+	err := jsonpb.UnmarshalString(`
+		{
+		  "instrumentation_library_spans": [
+			{
+			  "spans": [
 				{
-					Resource: &otlpresource.Resource{
-						Attributes: []*otlpcommon.KeyValue{
-							{
-								Key:   conventions.AttributeHostHostname,
-								Value: &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_StringValue{StringValue: "testHost"}},
-							},
-						},
-					},
-					InstrumentationLibrarySpans: []*otlptrace.InstrumentationLibrarySpans{
-						{
-							Spans: []*otlptrace.Span{
-								{
-									TraceId:           []byte{0x5B, 0x8E, 0xFF, 0xF7, 0x98, 0x3, 0x81, 0x3, 0xD2, 0x69, 0xB6, 0x33, 0x81, 0x3F, 0xC6, 0xC},
-									SpanId:            []byte{0xEE, 0xE1, 0x9B, 0x7E, 0xC3, 0xC1, 0xB1, 0x73},
-									Name:              "testSpan",
-									StartTimeUnixNano: 1544712660000000000,
-									EndTimeUnixNano:   1544712661000000000,
-									Attributes: []*otlpcommon.KeyValue{
-										{
-											Key:   "attr1",
-											Value: &otlpcommon.AnyValue{Value: &otlpcommon.AnyValue_IntValue{IntValue: 55}},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			})
-			assert.EqualValues(t, got, want)
+				}
+			  ]
+			}
+		  ]
+		}`, &resourceSpansOtlp2)
+	assert.NoError(t, err)
+	assert.EqualValues(t, otlpcommon.TraceID{}, resourceSpansOtlp2.InstrumentationLibrarySpans[0].Spans[0].TraceId)
+
+	tests := []struct {
+		name  string
+		json  string
+		bytes []byte
+	}{
+		{
+			name:  "empty string trace id",
+			json:  `""`,
+			bytes: nil,
+		},
+		{
+			name:  "zero bytes trace id",
+			json:  `"00000000000000000000000000000000"`,
+			bytes: []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var resourceSpansOtlp2 otlptrace.ResourceSpans
+			jsonStr := fmt.Sprintf(`
+			{
+			  "instrumentation_library_spans": [
+				{
+				  "spans": [
+					{
+					  "trace_id": %v
+					}
+				  ]
+				}
+			  ]
+			}`, test.json)
+			err := jsonpb.UnmarshalString(jsonStr, &resourceSpansOtlp2)
+			assert.NoError(t, err)
+			assert.EqualValues(t, otlpcommon.NewTraceID(test.bytes), resourceSpansOtlp2.InstrumentationLibrarySpans[0].Spans[0].TraceId)
 		})
 	}
 }
@@ -321,9 +389,7 @@ func TestProtoHttp(t *testing.T) {
 			got := gotOtlp[0]
 			want := wantOtlp[0]
 
-			// assert.Equal doesn't work on protos, see:
-			// https://github.com/stretchr/testify/issues/758
-			if !gogoproto.Equal(got, want) {
+			if !assert.EqualValues(t, got, want) {
 				t.Errorf("Sending trace proto over http failed\nGot:\n%v\nWant:\n%v\n",
 					got.String(),
 					want.String())
@@ -492,10 +558,12 @@ func TestOTLPReceiverTrace_HandleNextConsumerResponse(t *testing.T) {
 					{
 						Spans: []*otlptrace.Span{
 							{
-								TraceId: []byte{
-									0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
-									0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
-								},
+								TraceId: otlpcommon.NewTraceID(
+									[]byte{
+										0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
+										0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10,
+									},
+								),
 							},
 						},
 					},
diff --git a/receiver/otlpreceiver/trace/otlp_test.go b/receiver/otlpreceiver/trace/otlp_test.go
index 01e28fff776..7f7e8f0eebd 100644
--- a/receiver/otlpreceiver/trace/otlp_test.go
+++ b/receiver/otlpreceiver/trace/otlp_test.go
@@ -29,6 +29,7 @@ import (
 	"go.opentelemetry.io/collector/consumer/pdata"
 	"go.opentelemetry.io/collector/exporter/exportertest"
 	collectortrace "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/collector/trace/v1"
+	v1 "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/common/v1"
 	otlptrace "go.opentelemetry.io/collector/internal/data/opentelemetry-proto-gen/trace/v1"
 	"go.opentelemetry.io/collector/obsreport"
 	"go.opentelemetry.io/collector/testutil"
@@ -64,7 +65,7 @@ func TestExport(t *testing.T) {
 				{
 					Spans: []*otlptrace.Span{
 						{
-							TraceId:           traceID,
+							TraceId:           v1.NewTraceID(traceID),
 							SpanId:            spanID,
 							Name:              "operationB",
 							Kind:              otlptrace.Span_SPAN_KIND_SERVER,
diff --git a/receiver/zipkinreceiver/proto_parse_test.go b/receiver/zipkinreceiver/proto_parse_test.go
index fb952a859a6..3ceedc68057 100644
--- a/receiver/zipkinreceiver/proto_parse_test.go
+++ b/receiver/zipkinreceiver/proto_parse_test.go
@@ -127,7 +127,7 @@ func TestConvertSpansToTraceSpans_protobuf(t *testing.T) {
 				{
 					Spans: []*otlptrace.Span{
 						{
-							TraceId:           []byte{0x7F, 0x6F, 0x5F, 0x4F, 0x3F, 0x2F, 0x1F, 0x0F, 0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0},
+							TraceId:           otlpcommon.NewTraceID([]byte{0x7F, 0x6F, 0x5F, 0x4F, 0x3F, 0x2F, 0x1F, 0x0F, 0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0}),
 							SpanId:            []byte{0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0},
 							ParentSpanId:      []byte{0xF7, 0xF6, 0xF5, 0xF4, 0xF3, 0xF2, 0xF1, 0xF0},
 							Name:              "ProtoSpan1",
@@ -205,7 +205,7 @@ func TestConvertSpansToTraceSpans_protobuf(t *testing.T) {
 				{
 					Spans: []*otlptrace.Span{
 						{
-							TraceId:           []byte{0x7A, 0x6A, 0x5A, 0x4A, 0x3A, 0x2A, 0x1A, 0x0A, 0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0},
+							TraceId:           otlpcommon.NewTraceID([]byte{0x7A, 0x6A, 0x5A, 0x4A, 0x3A, 0x2A, 0x1A, 0x0A, 0xC7, 0xC6, 0xC5, 0xC4, 0xC3, 0xC2, 0xC1, 0xC0}),
 							SpanId:            []byte{0x67, 0x66, 0x65, 0x64, 0x63, 0x62, 0x61, 0x60},
 							ParentSpanId:      []byte{0x17, 0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10},
 							Name:              "CacheWarmUp",
diff --git a/service/internal/resources.go b/service/internal/resources.go
index 23e8c93fe9b..0e8b2e7bd0d 100644
--- a/service/internal/resources.go
+++ b/service/internal/resources.go
@@ -227,7 +227,7 @@ var _escData = map[string]*_escFile{
 		name:    "component_header.html",
 		local:   "templates/component_header.html",
 		size:    156,
-		modtime: 1589224191,
+		modtime: 1600087369,
 		compressed: `
 H4sIAAAAAAAC/1SMsQqDMBRFd7/iIq7q5lBiltKt9B8CPklQX6R1e9x/L6ZQ2vXcc65ZE3AZ0V3ztmcV
 PW467TnpQVZmzZp0Kfs96VJQizTjw1uyAgAXB+8C4lPmsT4fydqbdY+wCen64F0fB19iWV/yF/54X0en
@@ -239,7 +239,7 @@ U3kHAAD//zT+SdCcAAAA
 		name:    "extensions_table.html",
 		local:   "templates/extensions_table.html",
 		size:    353,
-		modtime: 1589224191,
+		modtime: 1600087369,
 		compressed: `
 H4sIAAAAAAAC/2SQwU7DMBBE7/2KlemRNJwjxxwQHDnwB248DRbOOnK2tGD531HTQIvqk1fzZjU7Wuw2
 gCb5CmjVNiaHVE2j7Tz3DT0osyIiynltqWlp8xSHMTJYntmN0bOUsgDJcg9ap3jw7HC8n7+z5y0epgU7
@@ -252,7 +252,7 @@ oxX5HeETfMGv9NPTkv4i2e6jT3HPrqE7AEui8yaECbdWkzPYUXWlaHFkg++5VR1YkJTRlt4Tdq06HVfK
 		name:    "footer.html",
 		local:   "templates/footer.html",
 		size:    15,
-		modtime: 1589224191,
+		modtime: 1600087369,
 		compressed: `
 H4sIAAAAAAAC/7LRT8pPqbTjstHPKMnNsQMEAAD//wEFevAPAAAA
 `,
@@ -262,7 +262,7 @@ H4sIAAAAAAAC/7LRT8pPqbTjstHPKMnNsQMEAAD//wEFevAPAAAA
 		name:    "header.html",
 		local:   "templates/header.html",
 		size:    467,
-		modtime: 1589224191,
+		modtime: 1600087369,
 		compressed: `
 H4sIAAAAAAAC/5TRMU8sIRAH8P4+BY/25eC9szGGxUItLIwW11giO7uMB8wG5rxsLvfdDdnTxNhoBeFP
 fpnM3/y5fbzZPj/dicAp2pVph4guj52ELK0J4Hq7EkIIk4Cd8MGVCtzJPQ/rS3mOGDmCPR7Vtl1OJ6OX
@@ -276,7 +276,7 @@ vuDEoocBiqjF/5RszGuV1uhFsCujl0bMC/Vz62vzZe1hY98DAAD//7qRGmLTAQAA
 		name:    "pipelines_table.html",
 		local:   "templates/pipelines_table.html",
 		size:    1946,
-		modtime: 1589224191,
+		modtime: 1600087369,
 		compressed: `
 H4sIAAAAAAAC/7SVwXLTMBCG7zyFxnRyIjVcU1scSpnhAMN0eAFZ2gRNlZVmJbdujd+dsWyrTp0LtL5k
 rOjX/tlv/8hFEJUB5sOjgTKrLCmgrXdCajzs2MeMv2OMsSLQ8DAsFJPWeCew/MSE0QcsDewDLyr+tTbm
@@ -293,7 +293,7 @@ QeMmXNC4hCvdNKvQgsYtacFoGWFFxSvCNl+lu3HQFXl8JfO/AQAA//9We3KLmgcAAA==
 		name:    "properties_table.html",
 		local:   "templates/properties_table.html",
 		size:    420,
-		modtime: 1589224191,
+		modtime: 1600087369,
 		compressed: `
 H4sIAAAAAAAC/2SRwW7DIBBE7/6KVRr1VMc5u5gfqFT11Ds2U8sqWVuwqRoR/r1yTCpb4YAEO48ZDarV
 MR7ezQkp1apqdaHEtA4U5OLQ7NrRW/gyTKYbuK/puNMFEVGMtB/Y4pfqho6UUr71hnvk0Qvt4XACyyw6
diff --git a/testbed/testbed/data_providers.go b/testbed/testbed/data_providers.go
index 4e90775b42f..34eca697a6a 100644
--- a/testbed/testbed/data_providers.go
+++ b/testbed/testbed/data_providers.go
@@ -41,7 +41,7 @@ type DataProvider interface {
 	// GenerateMetrics returns an internal MetricData instance with an OTLP ResourceMetrics slice of test data.
 	GenerateMetrics() (pdata.Metrics, bool)
 	// GetGeneratedSpan returns the generated Span matching the provided traceId and spanId or else nil if no match found.
-	GetGeneratedSpan(traceID []byte, spanID []byte) *otlptrace.Span
+	GetGeneratedSpan(traceID pdata.TraceID, spanID []byte) *otlptrace.Span
 	// GenerateLogs returns the internal pdata.Logs format
 	GenerateLogs() (pdata.Logs, bool)
 }
@@ -104,10 +104,10 @@ func (dp *PerfTestDataProvider) GenerateTraces() (pdata.Traces, bool) {
 	return traceData, false
 }
 
-func GenerateSequentialTraceID(id uint64) []byte {
+func GenerateSequentialTraceID(id uint64) pdata.TraceID {
 	var traceID [16]byte
 	binary.PutUvarint(traceID[:], id)
-	return traceID[:]
+	return pdata.NewTraceID(traceID[:])
 }
 
 func GenerateSequentialSpanID(id uint64) []byte {
@@ -161,7 +161,7 @@ func (dp *PerfTestDataProvider) GenerateMetrics() (pdata.Metrics, bool) {
 	return md, false
 }
 
-func (dp *PerfTestDataProvider) GetGeneratedSpan([]byte, []byte) *otlptrace.Span {
+func (dp *PerfTestDataProvider) GetGeneratedSpan(pdata.TraceID, []byte) *otlptrace.Span {
 	// function not supported for this data provider
 	return nil
 }
@@ -287,7 +287,7 @@ func (dp *GoldenDataProvider) GenerateLogs() (pdata.Logs, bool) {
 	return pdata.NewLogs(), true
 }
 
-func (dp *GoldenDataProvider) GetGeneratedSpan(traceID []byte, spanID []byte) *otlptrace.Span {
+func (dp *GoldenDataProvider) GetGeneratedSpan(traceID pdata.TraceID, spanID []byte) *otlptrace.Span {
 	if dp.spansMap == nil {
 		dp.spansMap = populateSpansMap(dp.resourceSpans)
 	}
@@ -300,7 +300,7 @@ func populateSpansMap(resourceSpansList []*otlptrace.ResourceSpans) map[string]*
 	for _, resourceSpans := range resourceSpansList {
 		for _, libSpans := range resourceSpans.InstrumentationLibrarySpans {
 			for _, span := range libSpans.Spans {
-				key := traceIDAndSpanIDToString(span.TraceId, span.SpanId)
+				key := traceIDAndSpanIDToString(pdata.TraceID(span.TraceId), span.SpanId)
 				spansMap[key] = span
 			}
 		}
@@ -308,6 +308,6 @@ func populateSpansMap(resourceSpansList []*otlptrace.ResourceSpans) map[string]*
 	return spansMap
 }
 
-func traceIDAndSpanIDToString(traceID []byte, spanID []byte) string {
-	return fmt.Sprintf("%s-%s", hex.EncodeToString(traceID), hex.EncodeToString(spanID))
+func traceIDAndSpanIDToString(traceID pdata.TraceID, spanID []byte) string {
+	return fmt.Sprintf("%s-%s", hex.EncodeToString(traceID.Bytes()), hex.EncodeToString(spanID))
 }
diff --git a/testbed/testbed/validator.go b/testbed/testbed/validator.go
index 21d25794581..741a1fa069e 100644
--- a/testbed/testbed/validator.go
+++ b/testbed/testbed/validator.go
@@ -128,7 +128,7 @@ func (v *CorrectnessTestValidator) assertSentRecdTracingDataEqual(tracesList []p
 		for _, rs := range resourceSpansList {
 			for _, ils := range rs.InstrumentationLibrarySpans {
 				for _, recdSpan := range ils.Spans {
-					sentSpan := v.dataProvider.GetGeneratedSpan(recdSpan.TraceId, recdSpan.SpanId)
+					sentSpan := v.dataProvider.GetGeneratedSpan(pdata.TraceID(recdSpan.TraceId), recdSpan.SpanId)
 					v.diffSpan(sentSpan, recdSpan)
 				}
 			}
@@ -160,13 +160,13 @@ func (v *CorrectnessTestValidator) diffSpan(sentSpan *otlptrace.Span, recdSpan *
 }
 
 func (v *CorrectnessTestValidator) diffSpanTraceID(sentSpan *otlptrace.Span, recdSpan *otlptrace.Span) {
-	if hex.EncodeToString(sentSpan.TraceId) != hex.EncodeToString(recdSpan.TraceId) {
+	if sentSpan.TraceId.HexString() != recdSpan.TraceId.HexString() {
 		af := &TraceAssertionFailure{
 			typeName:      "Span",
 			dataComboName: sentSpan.Name,
 			fieldPath:     "TraceId",
-			expectedValue: hex.EncodeToString(sentSpan.TraceId),
-			actualValue:   hex.EncodeToString(recdSpan.TraceId),
+			expectedValue: sentSpan.TraceId.HexString(),
+			actualValue:   recdSpan.TraceId.HexString(),
 		}
 		v.assertionFailures = append(v.assertionFailures, af)
 	}
diff --git a/translator/internaldata/oc_to_traces.go b/translator/internaldata/oc_to_traces.go
index d6835d079e3..081f14ae383 100644
--- a/translator/internaldata/oc_to_traces.go
+++ b/translator/internaldata/oc_to_traces.go
@@ -341,6 +341,7 @@ func ocLinksToInternal(ocLinks *octrace.Span_Links, dest pdata.Span) {
 		i++
 
 		link.SetTraceID(pdata.NewTraceID(ocLink.TraceId))
+
 		link.SetSpanID(pdata.NewSpanID(ocLink.SpanId))
 		link.SetTraceState(ocTraceStateToInternal(ocLink.Tracestate))
 		initAttributeMapFromOC(ocLink.Attributes, link.Attributes())
diff --git a/translator/trace/big_endian_converter.go b/translator/trace/big_endian_converter.go
index ca65e4f593c..98779aeca45 100644
--- a/translator/trace/big_endian_converter.go
+++ b/translator/trace/big_endian_converter.go
@@ -17,6 +17,8 @@ package tracetranslator
 import (
 	"encoding/binary"
 	"errors"
+
+	"go.opentelemetry.io/collector/consumer/pdata"
 )
 
 var (
@@ -30,6 +32,15 @@ var (
 	ErrWrongLenSpanID = errors.New("SpanID does not have 8 bytes")
 )
 
+// UInt64ToByteTraceID takes a two uint64 representation of a TraceID and
+// converts it to a []byte representation.
+func UInt64ToTraceID(high, low uint64) pdata.TraceID {
+	traceID := make([]byte, 16)
+	binary.BigEndian.PutUint64(traceID[:8], high)
+	binary.BigEndian.PutUint64(traceID[8:], low)
+	return pdata.NewTraceID(traceID)
+}
+
 // UInt64ToByteTraceID takes a two uint64 representation of a TraceID and
 // converts it to a []byte representation.
 func UInt64ToByteTraceID(high, low uint64) []byte {
@@ -39,6 +50,12 @@ func UInt64ToByteTraceID(high, low uint64) []byte {
 	return traceID
 }
 
+// Int64ToByteTraceID takes a two int64 representation of a TraceID and
+// converts it to a []byte representation.
+func Int64ToTraceID(high, low int64) pdata.TraceID {
+	return UInt64ToTraceID(uint64(high), uint64(low))
+}
+
 // Int64ToByteTraceID takes a two int64 representation of a TraceID and
 // converts it to a []byte representation.
 func Int64ToByteTraceID(high, low int64) []byte {
@@ -64,6 +81,11 @@ func BytesToInt64TraceID(traceID []byte) (int64, int64, error) {
 	return int64(traceIDHigh), int64(traceIDLow), err
 }
 
+// TraceIDToUInt64Pair takes a pdata.TraceID and converts it to a pair of uint64 representation.
+func TraceIDToUInt64Pair(traceID pdata.TraceID) (uint64, uint64, error) {
+	return BytesToUInt64TraceID(traceID.Bytes())
+}
+
 // UInt64ToByteSpanID takes a uint64 representation of a SpanID and
 // converts it to a []byte representation.
 func UInt64ToByteSpanID(id uint64) []byte {
diff --git a/translator/trace/jaeger/jaegerproto_to_traces.go b/translator/trace/jaeger/jaegerproto_to_traces.go
index 6f6bd00ad1a..923e5079806 100644
--- a/translator/trace/jaeger/jaegerproto_to_traces.go
+++ b/translator/trace/jaeger/jaegerproto_to_traces.go
@@ -172,7 +172,7 @@ type instrumentationLibrary struct {
 func jSpanToInternal(span *model.Span) (pdata.Span, instrumentationLibrary) {
 	dest := pdata.NewSpan()
 	dest.InitEmpty()
-	dest.SetTraceID(tracetranslator.UInt64ToByteTraceID(span.TraceID.High, span.TraceID.Low))
+	dest.SetTraceID(tracetranslator.UInt64ToTraceID(span.TraceID.High, span.TraceID.Low))
 	dest.SetSpanID(tracetranslator.UInt64ToByteSpanID(uint64(span.SpanID)))
 	dest.SetName(span.OperationName)
 	dest.SetStartTime(pdata.TimestampUnixNano(uint64(span.StartTime.UnixNano())))
@@ -365,7 +365,7 @@ func jReferencesToSpanLinks(refs []model.SpanRef, excludeParentID model.SpanID,
 			continue
 		}
 
-		link.SetTraceID(pdata.NewTraceID(tracetranslator.UInt64ToByteTraceID(ref.TraceID.High, ref.TraceID.Low)))
+		link.SetTraceID(tracetranslator.UInt64ToTraceID(ref.TraceID.High, ref.TraceID.Low))
 		link.SetSpanID(pdata.NewSpanID(tracetranslator.UInt64ToByteSpanID(uint64(ref.SpanID))))
 		i++
 	}
diff --git a/translator/trace/jaeger/jaegerthrift_to_traces.go b/translator/trace/jaeger/jaegerthrift_to_traces.go
index 54859beadbb..e3e3a6075b2 100644
--- a/translator/trace/jaeger/jaegerthrift_to_traces.go
+++ b/translator/trace/jaeger/jaegerthrift_to_traces.go
@@ -99,7 +99,7 @@ func jThriftSpansToInternal(spans []*jaeger.Span, dest pdata.SpanSlice) {
 }
 
 func jThriftSpanToInternal(span *jaeger.Span, dest pdata.Span) {
-	dest.SetTraceID(tracetranslator.Int64ToByteTraceID(span.TraceIdHigh, span.TraceIdLow))
+	dest.SetTraceID(tracetranslator.Int64ToTraceID(span.TraceIdHigh, span.TraceIdLow))
 	dest.SetSpanID(tracetranslator.Int64ToByteSpanID(span.SpanId))
 	dest.SetName(span.OperationName)
 	dest.SetStartTime(microsecondsToUnixNano(span.StartTime))
@@ -186,7 +186,7 @@ func jThriftReferencesToSpanLinks(refs []*jaeger.SpanRef, excludeParentID int64,
 			continue
 		}
 
-		link.SetTraceID(pdata.NewTraceID(tracetranslator.Int64ToByteTraceID(ref.TraceIdHigh, ref.TraceIdLow)))
+		link.SetTraceID(tracetranslator.Int64ToTraceID(ref.TraceIdHigh, ref.TraceIdLow))
 		link.SetSpanID(pdata.NewSpanID(tracetranslator.Int64ToByteSpanID(ref.SpanId)))
 		i++
 	}
diff --git a/translator/trace/jaeger/traces_to_jaegerproto.go b/translator/trace/jaeger/traces_to_jaegerproto.go
index 9ac79b9c6ea..368835a68b0 100644
--- a/translator/trace/jaeger/traces_to_jaegerproto.go
+++ b/translator/trace/jaeger/traces_to_jaegerproto.go
@@ -274,7 +274,7 @@ func getJaegerProtoSpanTags(span pdata.Span, instrumentationLibrary pdata.Instru
 }
 
 func traceIDToJaegerProto(traceID pdata.TraceID) (model.TraceID, error) {
-	traceIDHigh, traceIDLow, err := tracetranslator.BytesToUInt64TraceID(traceID)
+	traceIDHigh, traceIDLow, err := tracetranslator.TraceIDToUInt64Pair(traceID)
 	if err != nil {
 		return model.TraceID{}, err
 	}
diff --git a/translator/trace/zipkin/traces_to_zipkinv2.go b/translator/trace/zipkin/traces_to_zipkinv2.go
index 44d9b67a4a7..912de53e8ce 100644
--- a/translator/trace/zipkin/traces_to_zipkinv2.go
+++ b/translator/trace/zipkin/traces_to_zipkinv2.go
@@ -111,7 +111,7 @@ func spanToZipkinSpan(
 
 	zs := &zipkinmodel.SpanModel{}
 
-	hi, lo, err := tracetranslator.BytesToUInt64TraceID(span.TraceID().Bytes())
+	hi, lo, err := tracetranslator.TraceIDToUInt64Pair(span.TraceID())
 	if err != nil {
 		return nil, err
 	}
@@ -230,7 +230,7 @@ func spanLinksToZipkinTags(links pdata.SpanLinkSlice, zTags map[string]string) e
 			if err != nil {
 				return err
 			}
-			zTags[key] = fmt.Sprintf(tracetranslator.SpanLinkDataFormat, link.TraceID().String(),
+			zTags[key] = fmt.Sprintf(tracetranslator.SpanLinkDataFormat, link.TraceID().HexString(),
 				link.SpanID().String(), link.TraceState(), jsonStr, link.DroppedAttributesCount())
 		}
 	}
diff --git a/translator/trace/zipkin/zipkinv2_to_traces.go b/translator/trace/zipkin/zipkinv2_to_traces.go
index 8d01e0c517b..3a56bf6c478 100644
--- a/translator/trace/zipkin/zipkinv2_to_traces.go
+++ b/translator/trace/zipkin/zipkinv2_to_traces.go
@@ -127,7 +127,7 @@ func V2SpansToInternalTraces(zipkinSpans []*zipkinmodel.SpanModel) (pdata.Traces
 func zSpanToInternal(zspan *zipkinmodel.SpanModel, tags map[string]string, dest pdata.Span) error {
 	dest.InitEmpty()
 
-	dest.SetTraceID(tracetranslator.UInt64ToByteTraceID(zspan.TraceID.High, zspan.TraceID.Low))
+	dest.SetTraceID(tracetranslator.UInt64ToTraceID(zspan.TraceID.High, zspan.TraceID.Low))
 	dest.SetSpanID(tracetranslator.UInt64ToByteSpanID(uint64(zspan.ID)))
 	if value, ok := tags[tracetranslator.TagW3CTraceState]; ok {
 		dest.SetTraceState(pdata.TraceState(value))
@@ -211,16 +211,21 @@ func zTagsToSpanLinks(tags map[string]string, dest pdata.SpanLinkSlice) error {
 		link := dest.At(index)
 		index++
 		link.InitEmpty()
+
+		// Convert trace id.
 		rawTrace, errTrace := hex.DecodeString(parts[0])
 		if errTrace != nil {
 			return errTrace
 		}
 		link.SetTraceID(pdata.NewTraceID(rawTrace))
+
+		// Convert span id.
 		rawSpan, errSpan := hex.DecodeString(parts[1])
 		if errSpan != nil {
 			return errSpan
 		}
 		link.SetSpanID(pdata.NewSpanID(rawSpan))
+
 		link.SetTraceState(pdata.TraceState(parts[2]))
 
 		var jsonStr string
diff --git a/translator/trace/zipkin/zipkinv2_to_traces_test.go b/translator/trace/zipkin/zipkinv2_to_traces_test.go
index a5fc8ab3c55..9362d967fdd 100644
--- a/translator/trace/zipkin/zipkinv2_to_traces_test.go
+++ b/translator/trace/zipkin/zipkinv2_to_traces_test.go
@@ -80,7 +80,7 @@ func generateSpanNoEndpoints() []*zipkinmodel.SpanModel {
 	spans[0] = &zipkinmodel.SpanModel{
 		SpanContext: zipkinmodel.SpanContext{
 			TraceID: convertTraceID(
-				[]byte{0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x80}),
+				pdata.NewTraceID([]byte{0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x80})),
 			ID: convertSpanID([]byte{0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8}),
 		},
 		Name:           "MinimalData",
@@ -113,7 +113,7 @@ func generateTraceSingleSpanNoResourceOrInstrLibrary() pdata.Traces {
 	ils.Spans().Resize(1)
 	span := ils.Spans().At(0)
 	span.SetTraceID(
-		[]byte{0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x80})
+		pdata.NewTraceID([]byte{0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x80}))
 	span.SetSpanID([]byte{0xAF, 0xAE, 0xAD, 0xAC, 0xAB, 0xAA, 0xA9, 0xA8})
 	span.SetName("MinimalData")
 	span.SetKind(pdata.SpanKindCLIENT)
@@ -133,8 +133,8 @@ func generateTraceSingleSpanMinmalResource() pdata.Traces {
 	return td
 }
 
-func convertTraceID(t []byte) zipkinmodel.TraceID {
-	h, l, _ := tracetranslator.BytesToUInt64TraceID(t)
+func convertTraceID(t pdata.TraceID) zipkinmodel.TraceID {
+	h, l, _ := tracetranslator.TraceIDToUInt64Pair(t)
 	return zipkinmodel.TraceID{High: h, Low: l}
 }