diff --git a/cmd/agent/app/reporter/grpc/collector_proxy_test.go b/cmd/agent/app/reporter/grpc/collector_proxy_test.go
index 7c4433e2ab9..e49d5bb9608 100644
--- a/cmd/agent/app/reporter/grpc/collector_proxy_test.go
+++ b/cmd/agent/app/reporter/grpc/collector_proxy_test.go
@@ -61,9 +61,9 @@ func TestMultipleCollectors(t *testing.T) {
 	assert.NotNil(t, proxy.GetManager())
 
 	var bothServers = false
+	r := proxy.GetReporter()
 	// TODO do not iterate, just create two batches
-	for i := 0; i < 10; i++ {
-		r := proxy.GetReporter()
+	for i := 0; i < 100; i++ {
 		err := r.EmitBatch(&jaeger.Batch{Spans: []*jaeger.Span{{OperationName: "op"}}, Process: &jaeger.Process{ServiceName: "service"}})
 		require.NoError(t, err)
 		if len(spanHandler1.getRequests()) > 0 && len(spanHandler2.getRequests()) > 0 {
diff --git a/cmd/agent/app/reporter/grpc/reporter.go b/cmd/agent/app/reporter/grpc/reporter.go
index 88d63235890..38f3425dee9 100644
--- a/cmd/agent/app/reporter/grpc/reporter.go
+++ b/cmd/agent/app/reporter/grpc/reporter.go
@@ -20,6 +20,7 @@ import (
 	"go.uber.org/zap"
 	"google.golang.org/grpc"
 
+	zipkin2 "github.com/jaegertracing/jaeger/cmd/collector/app/sanitizer/zipkin"
 	"github.com/jaegertracing/jaeger/model"
 	jConverter "github.com/jaegertracing/jaeger/model/converter/thrift/jaeger"
 	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"
@@ -32,6 +33,7 @@ import (
 type Reporter struct {
 	collector api_v2.CollectorServiceClient
 	logger    *zap.Logger
+	sanitizer zipkin2.Sanitizer
 }
 
 // NewReporter creates gRPC reporter.
@@ -39,35 +41,33 @@ func NewReporter(conn *grpc.ClientConn, logger *zap.Logger) *Reporter {
 	return &Reporter{
 		collector: api_v2.NewCollectorServiceClient(conn),
 		logger:    logger,
+		sanitizer: zipkin2.NewChainedSanitizer(zipkin2.StandardSanitizers...),
 	}
 }
 
 // EmitBatch implements EmitBatch() of Reporter
 func (r *Reporter) EmitBatch(b *thrift.Batch) error {
-	// TODO pass process to r.send() - do not convert it for every span
-	spans := jConverter.ToDomain(b.Spans, b.Process)
-	return r.send(spans)
+	return r.send(jConverter.ToDomain(b.Spans, nil), jConverter.ToDomainProcess(b.Process))
 }
 
 // EmitZipkinBatch implements EmitZipkinBatch() of Reporter
 func (r *Reporter) EmitZipkinBatch(zSpans []*zipkincore.Span) error {
+	for _, zSpan := range zSpans {
+		zSpan = r.sanitizer.Sanitize(zSpan)
+	}
 	trace, err := zipkin.ToDomain(zSpans)
 	if err != nil {
 		return err
 	}
-	return r.send(trace.Spans)
+	return r.send(trace.Spans, nil)
 }
 
-func (r *Reporter) send(spans []*model.Span) error {
-	var process model.Process
-	if len(spans) > 0 {
-		process = *spans[0].Process
-	}
+func (r *Reporter) send(spans []*model.Span, process *model.Process) error {
 	batch := model.Batch{Spans: spans, Process: process}
 	req := &api_v2.PostSpansRequest{Batch: batch}
 	_, err := r.collector.PostSpans(context.Background(), req)
 	if err != nil {
-		r.logger.Error("Could not send spans over gRPC", zap.Error(err), zap.String("service", batch.Process.ServiceName))
+		r.logger.Error("Could not send spans over gRPC", zap.Error(err))
 	}
 	return err
 }
diff --git a/cmd/agent/app/reporter/grpc/reporter_test.go b/cmd/agent/app/reporter/grpc/reporter_test.go
index c38e78707b0..89d94c5b9e5 100644
--- a/cmd/agent/app/reporter/grpc/reporter_test.go
+++ b/cmd/agent/app/reporter/grpc/reporter_test.go
@@ -69,8 +69,8 @@ func TestReporter_EmitZipkinBatch(t *testing.T) {
 	}{
 		{in: &zipkincore.Span{}, err: "Cannot find service name in Zipkin span [traceID=0, spanID=0]"},
 		{in: &zipkincore.Span{Name: "jonatan", TraceID: 1, ID: 2, Timestamp: &a, Annotations: []*zipkincore.Annotation{{Value: zipkincore.CLIENT_SEND, Host: &zipkincore.Endpoint{ServiceName: "spring"}}}},
-			expected: model.Batch{Process: model.Process{ServiceName: "spring"},
-				Spans: []*model.Span{{TraceID: model.NewTraceID(0, 1), SpanID: model.NewSpanID(2), OperationName: "jonatan",
+			expected: model.Batch{
+				Spans: []*model.Span{{TraceID: model.NewTraceID(0, 1), SpanID: model.NewSpanID(2), OperationName: "jonatan", Duration: time.Microsecond * 1,
 					Tags: model.KeyValues{{Key: "span.kind", VStr: "client", VType: model.StringType}}, Process: &model.Process{ServiceName: "spring"}, StartTime: tm.UTC()}}}},
 	}
 	for _, test := range tests {
@@ -102,7 +102,7 @@ func TestReporter_EmitBatch(t *testing.T) {
 		err      string
 	}{
 		{in: &jThrift.Batch{Process: &jThrift.Process{ServiceName: "node"}, Spans: []*jThrift.Span{{OperationName: "foo", StartTime: int64(model.TimeAsEpochMicroseconds(tm))}}},
-			expected: model.Batch{Process: model.Process{ServiceName: "node"}, Spans: []*model.Span{{OperationName: "foo", StartTime: tm.UTC(), Process: &model.Process{ServiceName: "node"}}}}},
+			expected: model.Batch{Process: &model.Process{ServiceName: "node"}, Spans: []*model.Span{{OperationName: "foo", StartTime: tm.UTC()}}}},
 	}
 	for _, test := range tests {
 		err = rep.EmitBatch(test.in)
@@ -119,6 +119,6 @@ func TestReporter_SendFailure(t *testing.T) {
 	conn, err := grpc.Dial("", grpc.WithInsecure())
 	require.NoError(t, err)
 	rep := NewReporter(conn, zap.NewNop())
-	err = rep.send(nil)
+	err = rep.send(nil, nil)
 	assert.EqualError(t, err, "rpc error: code = Unavailable desc = all SubConns are in TransientFailure, latest connection error: connection error: desc = \"transport: Error while dialing dial tcp: missing address\"")
 }
diff --git a/cmd/collector/app/builder/span_handler_builder.go b/cmd/collector/app/builder/span_handler_builder.go
index 3a5d4f0ff5e..19a6ffb67a2 100644
--- a/cmd/collector/app/builder/span_handler_builder.go
+++ b/cmd/collector/app/builder/span_handler_builder.go
@@ -65,13 +65,6 @@ func (spanHb *SpanHandlerBuilder) BuildHandlers() (
 	hostname, _ := os.Hostname()
 	hostMetrics := spanHb.metricsFactory.Namespace("", map[string]string{"host": hostname})
 
-	zSanitizer := zs.NewChainedSanitizer(
-		zs.NewSpanDurationSanitizer(),
-		zs.NewSpanStartTimeSanitizer(),
-		zs.NewParentIDSanitizer(),
-		zs.NewErrorTagSanitizer(),
-	)
-
 	spanProcessor := app.NewSpanProcessor(
 		spanHb.spanWriter,
 		app.Options.ServiceMetrics(spanHb.metricsFactory),
@@ -82,7 +75,7 @@ func (spanHb *SpanHandlerBuilder) BuildHandlers() (
 		app.Options.QueueSize(spanHb.collectorOpts.QueueSize),
 	)
 
-	return app.NewZipkinSpanHandler(spanHb.logger, spanProcessor, zSanitizer),
+	return app.NewZipkinSpanHandler(spanHb.logger, spanProcessor, zs.NewChainedSanitizer(zs.StandardSanitizers...)),
 		app.NewJaegerSpanHandler(spanHb.logger, spanProcessor),
 		app.NewGRPCHandler(spanHb.logger, spanProcessor)
 }
diff --git a/cmd/collector/app/grpc_handler.go b/cmd/collector/app/grpc_handler.go
index 7d59f6268e2..6a6adead87b 100644
--- a/cmd/collector/app/grpc_handler.go
+++ b/cmd/collector/app/grpc_handler.go
@@ -40,7 +40,7 @@ func NewGRPCHandler(logger *zap.Logger, spanProcessor SpanProcessor) *GRPCHandle
 func (g *GRPCHandler) PostSpans(ctx context.Context, r *api_v2.PostSpansRequest) (*api_v2.PostSpansResponse, error) {
 	for _, span := range r.GetBatch().Spans {
 		if span.GetProcess() == nil {
-			span.Process = &r.Batch.Process
+			span.Process = r.Batch.Process
 		}
 	}
 	_, err := g.spanProcessor.ProcessSpans(r.GetBatch().Spans, JaegerFormatType)
diff --git a/cmd/collector/app/grpc_handler_test.go b/cmd/collector/app/grpc_handler_test.go
index d1b1606ef24..50680a94595 100644
--- a/cmd/collector/app/grpc_handler_test.go
+++ b/cmd/collector/app/grpc_handler_test.go
@@ -88,9 +88,9 @@ func TestPostSpans(t *testing.T) {
 		batch    model.Batch
 		expected []*model.Span
 	}{
-		{batch: model.Batch{Process: model.Process{ServiceName: "batch-process"}, Spans: []*model.Span{{OperationName: "test-op", Process: &model.Process{ServiceName: "bar"}}}},
+		{batch: model.Batch{Process: &model.Process{ServiceName: "batch-process"}, Spans: []*model.Span{{OperationName: "test-op", Process: &model.Process{ServiceName: "bar"}}}},
 			expected: []*model.Span{{OperationName: "test-op", Process: &model.Process{ServiceName: "bar"}}}},
-		{batch: model.Batch{Process: model.Process{ServiceName: "batch-process"}, Spans: []*model.Span{{OperationName: "test-op"}}},
+		{batch: model.Batch{Process: &model.Process{ServiceName: "batch-process"}, Spans: []*model.Span{{OperationName: "test-op"}}},
 			expected: []*model.Span{{OperationName: "test-op", Process: &model.Process{ServiceName: "batch-process"}}}},
 	}
 	for _, test := range tests {
diff --git a/cmd/collector/app/sanitizer/zipkin/span_sanitizer.go b/cmd/collector/app/sanitizer/zipkin/span_sanitizer.go
index b6001716bce..e6655a10ffd 100644
--- a/cmd/collector/app/sanitizer/zipkin/span_sanitizer.go
+++ b/cmd/collector/app/sanitizer/zipkin/span_sanitizer.go
@@ -28,6 +28,8 @@ const (
 
 var (
 	defaultDuration = int64(1)
+	// StandardSanitizers is a list of standard zipkin sanitizers.
+	StandardSanitizers = []Sanitizer{NewSpanStartTimeSanitizer(), NewSpanDurationSanitizer(), NewParentIDSanitizer(), NewErrorTagSanitizer()}
 )
 
 // Sanitizer interface for sanitizing spans. Any business logic that needs to be applied to normalize the contents of a
diff --git a/model/converter/thrift/jaeger/to_domain.go b/model/converter/thrift/jaeger/to_domain.go
index d3652f9bfc8..a5f0cc9543b 100644
--- a/model/converter/thrift/jaeger/to_domain.go
+++ b/model/converter/thrift/jaeger/to_domain.go
@@ -35,6 +35,11 @@ func ToDomainSpan(jSpan *jaeger.Span, jProcess *jaeger.Process) *model.Span {
 	return toDomain{}.ToDomainSpan(jSpan, jProcess)
 }
 
+// ToDomainProcess transforms a process in jaeger.thrift format to model.Span.
+func ToDomainProcess(jProcess *jaeger.Process) *model.Process {
+	return toDomain{}.getProcess(jProcess)
+}
+
 type toDomain struct{}
 
 func (td toDomain) ToDomain(jSpans []*jaeger.Span, jProcess *jaeger.Process) []*model.Span {
@@ -96,6 +101,9 @@ func (td toDomain) getReferences(jRefs []*jaeger.SpanRef) []model.SpanRef {
 // getProcess takes a jaeger.thrift process and produces a model.Process.
 // Any errors are presented as tags
 func (td toDomain) getProcess(jProcess *jaeger.Process) *model.Process {
+	if jProcess == nil {
+		return nil
+	}
 	tags := td.getTags(jProcess.Tags)
 	return &model.Process{
 		Tags:        tags,
diff --git a/model/converter/thrift/jaeger/to_domain_test.go b/model/converter/thrift/jaeger/to_domain_test.go
index 6b6a5c6cf2a..b22323876e2 100644
--- a/model/converter/thrift/jaeger/to_domain_test.go
+++ b/model/converter/thrift/jaeger/to_domain_test.go
@@ -19,6 +19,7 @@ import (
 	"fmt"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/gogo/protobuf/jsonpb"
 	"github.com/gogo/protobuf/proto"
@@ -102,3 +103,14 @@ func TestUnknownJaegerType(t *testing.T) {
 	expected := model.String("sneh", "Unknown VType: Tag({Key:sneh VType:<UNSET> VStr:<nil> VDouble:<nil> VBool:<nil> VLong:<nil> VBinary:[]})")
 	assert.Equal(t, mkv, expected)
 }
+
+func TestToDomain_ToDomainProcess(t *testing.T) {
+	p := ToDomainProcess(&jaeger.Process{ServiceName: "foo", Tags: []*jaeger.Tag{{Key: "foo", VType: jaeger.TagType_BOOL}}})
+	assert.Equal(t, &model.Process{ServiceName: "foo", Tags: []model.KeyValue{{Key: "foo", VType: model.BoolType}}}, p)
+}
+
+func TestToDomain_ToDomainSpanProcessNull(t *testing.T) {
+	tm := time.Unix(158, 0)
+	s := ToDomainSpan(&jaeger.Span{OperationName: "foo", StartTime: int64(model.TimeAsEpochMicroseconds(tm))}, nil)
+	assert.Equal(t, &model.Span{OperationName: "foo", StartTime: tm.UTC()}, s)
+}
diff --git a/model/model.pb.go b/model/model.pb.go
index a28b54c1cd5..a2877bd5feb 100644
--- a/model/model.pb.go
+++ b/model/model.pb.go
@@ -370,8 +370,8 @@ func (m *Trace_ProcessMapping) GetProcess() Process {
 }
 
 type Batch struct {
-	Spans   []*Span `protobuf:"bytes,1,rep,name=spans" json:"spans,omitempty"`
-	Process Process `protobuf:"bytes,2,opt,name=process" json:"process"`
+	Spans   []*Span  `protobuf:"bytes,1,rep,name=spans" json:"spans,omitempty"`
+	Process *Process `protobuf:"bytes,2,opt,name=process" json:"process,omitempty"`
 }
 
 func (m *Batch) Reset()                    { *m = Batch{} }
@@ -386,11 +386,11 @@ func (m *Batch) GetSpans() []*Span {
 	return nil
 }
 
-func (m *Batch) GetProcess() Process {
+func (m *Batch) GetProcess() *Process {
 	if m != nil {
 		return m.Process
 	}
-	return Process{}
+	return nil
 }
 
 func init() {
@@ -948,14 +948,16 @@ func (m *Batch) MarshalTo(dAtA []byte) (int, error) {
 			i += n
 		}
 	}
-	dAtA[i] = 0x12
-	i++
-	i = encodeVarintModel(dAtA, i, uint64(m.Process.Size()))
-	n10, err := m.Process.MarshalTo(dAtA[i:])
-	if err != nil {
-		return 0, err
+	if m.Process != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintModel(dAtA, i, uint64(m.Process.Size()))
+		n10, err := m.Process.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n10
 	}
-	i += n10
 	return i, nil
 }
 
@@ -1139,8 +1141,10 @@ func (m *Batch) Size() (n int) {
 			n += 1 + l + sovModel(uint64(l))
 		}
 	}
-	l = m.Process.Size()
-	n += 1 + l + sovModel(uint64(l))
+	if m.Process != nil {
+		l = m.Process.Size()
+		n += 1 + l + sovModel(uint64(l))
+	}
 	return n
 }
 
@@ -2453,6 +2457,9 @@ func (m *Batch) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
+			if m.Process == nil {
+				m.Process = &Process{}
+			}
 			if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
@@ -2587,62 +2594,62 @@ func init() { proto.RegisterFile("model.proto", fileDescriptorModel) }
 func init() { golang_proto.RegisterFile("model.proto", fileDescriptorModel) }
 
 var fileDescriptorModel = []byte{
-	// 903 bytes of a gzipped FileDescriptorProto
+	// 905 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x55, 0x41, 0x8f, 0xdb, 0x44,
 	0x14, 0xde, 0x49, 0xec, 0xd8, 0x79, 0x49, 0x56, 0xd1, 0x14, 0x58, 0x37, 0xa0, 0x24, 0xa4, 0x42,
 	0x0a, 0x55, 0x49, 0xda, 0xd0, 0xee, 0x01, 0x21, 0xa1, 0xba, 0x4b, 0xc0, 0x90, 0xdd, 0xa0, 0xd9,
 	0x08, 0x04, 0x17, 0x6b, 0x36, 0x99, 0x18, 0x17, 0xc7, 0x63, 0xd9, 0x5e, 0xa3, 0xdc, 0xf8, 0x09,
 	0x88, 0x13, 0x47, 0xb8, 0xf2, 0x2b, 0x38, 0xf6, 0xc8, 0x81, 0x13, 0x12, 0x0b, 0x0a, 0x97, 0xfe,
-	0x0c, 0x34, 0xe3, 0x71, 0xb6, 0x1b, 0x2a, 0x58, 0x38, 0x70, 0xf2, 0xcc, 0xbc, 0xef, 0xbd, 0xf9,
-	0xde, 0xf7, 0x3e, 0xdb, 0x50, 0x5b, 0xf1, 0x05, 0x0b, 0x06, 0x51, 0xcc, 0x53, 0x8e, 0x1b, 0x8f,
-	0x29, 0xf3, 0x58, 0x3c, 0xa0, 0x91, 0xef, 0x66, 0xa3, 0xd6, 0x0b, 0x1e, 0xf7, 0xb8, 0x8c, 0x0c,
-	0xc5, 0x2a, 0x07, 0xb5, 0x5e, 0xf1, 0x38, 0xf7, 0x02, 0x36, 0xa4, 0x91, 0x3f, 0xa4, 0x61, 0xc8,
-	0x53, 0x9a, 0xfa, 0x3c, 0x4c, 0x54, 0xb4, 0xa3, 0xa2, 0x72, 0x77, 0x76, 0xbe, 0x1c, 0xa6, 0xfe,
-	0x8a, 0x25, 0x29, 0x5d, 0x45, 0x0a, 0xd0, 0xde, 0x05, 0x2c, 0xce, 0x63, 0x59, 0x21, 0x8f, 0xf7,
-	0x7e, 0x46, 0x60, 0x7e, 0xc8, 0xd6, 0x1f, 0xd3, 0xe0, 0x9c, 0xe1, 0x26, 0x94, 0xbf, 0x60, 0x6b,
-	0x0b, 0x75, 0x51, 0xbf, 0x4a, 0xc4, 0x12, 0x0f, 0xa1, 0x92, 0xb9, 0xe9, 0x3a, 0x62, 0x56, 0xa9,
-	0x8b, 0xfa, 0xfb, 0x23, 0x6b, 0x70, 0x85, 0xf3, 0x40, 0xe6, 0xcd, 0xd6, 0x11, 0x23, 0x7a, 0x26,
-	0x1e, 0xf8, 0x06, 0xe8, 0x99, 0x9b, 0xa4, 0xb1, 0x55, 0x96, 0x45, 0xb4, 0xec, 0x34, 0x8d, 0xf1,
-	0x8b, 0xa2, 0xca, 0x19, 0xe7, 0x81, 0xa5, 0x75, 0x51, 0xdf, 0x24, 0x7a, 0x66, 0x73, 0x1e, 0xe0,
-	0x03, 0x30, 0x32, 0xd7, 0x0f, 0xd3, 0xc3, 0xfb, 0x96, 0xde, 0x45, 0xfd, 0x32, 0xa9, 0x64, 0x8e,
-	0xd8, 0xe1, 0x97, 0xa1, 0x9a, 0xb9, 0xcb, 0x80, 0x53, 0x11, 0xaa, 0x74, 0x51, 0x1f, 0x11, 0x33,
-	0x1b, 0xe7, 0x7b, 0x7c, 0x13, 0xcc, 0xcc, 0x3d, 0xf3, 0x43, 0x1a, 0xaf, 0x2d, 0xa3, 0x8b, 0xfa,
-	0x75, 0x62, 0x64, 0xb6, 0xdc, 0xbe, 0x65, 0x3e, 0xfd, 0xae, 0x83, 0x9e, 0x7e, 0xdf, 0x41, 0xbd,
-	0xaf, 0x10, 0x94, 0x27, 0xdc, 0xc3, 0x36, 0x54, 0xb7, 0x8a, 0xc8, 0xbe, 0x6a, 0xa3, 0xd6, 0x20,
-	0x97, 0x64, 0x50, 0x48, 0x32, 0x98, 0x15, 0x08, 0xdb, 0x7c, 0x72, 0xd1, 0xd9, 0xfb, 0xfa, 0xb7,
-	0x0e, 0x22, 0x97, 0x69, 0xf8, 0x01, 0x54, 0x96, 0x3e, 0x0b, 0x16, 0x89, 0x55, 0xea, 0x96, 0xfb,
-	0xb5, 0xd1, 0xc1, 0x8e, 0x06, 0x85, 0x7c, 0xb6, 0x26, 0xb2, 0x89, 0x02, 0xf7, 0x7e, 0x40, 0x60,
-	0x9c, 0x46, 0x34, 0x24, 0x6c, 0x89, 0x1f, 0x80, 0x99, 0xc6, 0x74, 0xce, 0x5c, 0x7f, 0x21, 0x59,
-	0xd4, 0xed, 0x96, 0xc0, 0xfe, 0x72, 0xd1, 0x31, 0x66, 0xe2, 0xdc, 0x39, 0xda, 0x5c, 0x2e, 0x89,
-	0x21, 0xb1, 0xce, 0x02, 0xdf, 0x03, 0x23, 0x89, 0x68, 0x28, 0xb2, 0x4a, 0x32, 0xcb, 0x52, 0x59,
-	0x15, 0x51, 0x58, 0x26, 0xa9, 0x15, 0xa9, 0x08, 0xa0, 0xb3, 0x10, 0x37, 0xc5, 0x6c, 0x99, 0x8f,
-	0xac, 0x2c, 0x47, 0xd6, 0xda, 0xa1, 0xab, 0x38, 0xc9, 0xa1, 0x19, 0x71, 0xbe, 0xe8, 0xb9, 0x60,
-	0x7c, 0x14, 0xf3, 0x39, 0x4b, 0x12, 0xfc, 0x2a, 0xd4, 0x13, 0x16, 0x67, 0xfe, 0x9c, 0xb9, 0x21,
-	0x5d, 0x31, 0xe5, 0x86, 0x9a, 0x3a, 0x3b, 0xa1, 0x2b, 0x86, 0xef, 0x81, 0x96, 0x52, 0xef, 0x9a,
-	0x7a, 0x48, 0x68, 0xef, 0x57, 0x0d, 0x34, 0x71, 0xf3, 0xff, 0x28, 0xc5, 0x6b, 0xb0, 0xcf, 0x23,
-	0x96, 0xbb, 0x3d, 0x6f, 0x25, 0xf7, 0x64, 0x63, 0x7b, 0x2a, 0x9b, 0x79, 0x1b, 0x20, 0x66, 0x4b,
-	0x16, 0xb3, 0x70, 0xce, 0x12, 0x4b, 0x93, 0x2d, 0xbd, 0xf4, 0x7c, 0xcd, 0x54, 0x47, 0xcf, 0xe0,
-	0xf1, 0x2d, 0xd0, 0x97, 0x81, 0xd0, 0x42, 0x38, 0xb8, 0x61, 0x37, 0x14, 0x2b, 0x7d, 0x2c, 0x0e,
-	0x49, 0x1e, 0xc3, 0x8f, 0x00, 0x92, 0x94, 0xc6, 0xa9, 0x2b, 0x4c, 0x25, 0x0d, 0x7d, 0x6d, 0x1b,
-	0xca, 0x3c, 0x11, 0xc1, 0xef, 0x80, 0x59, 0xbc, 0xbb, 0xd2, 0xf7, 0xb5, 0xd1, 0xcd, 0xbf, 0x94,
-	0x38, 0x52, 0x80, 0xbc, 0xc2, 0xb7, 0xa2, 0xc2, 0x36, 0x69, 0x3b, 0x35, 0xf3, 0xda, 0x53, 0xc3,
-	0x77, 0x40, 0x0b, 0xb8, 0x97, 0x58, 0x55, 0x99, 0x82, 0x77, 0x52, 0x26, 0xdc, 0x2b, 0xd0, 0x02,
-	0x85, 0xef, 0x82, 0x11, 0xe5, 0x26, 0xb2, 0x40, 0x12, 0xdc, 0x95, 0x51, 0x59, 0x8c, 0x14, 0x30,
-	0x7c, 0x07, 0x40, 0x2d, 0xc5, 0x60, 0x6b, 0x62, 0x3c, 0x76, 0x63, 0x73, 0xd1, 0xa9, 0x2a, 0xa4,
-	0x73, 0x44, 0xaa, 0x0a, 0xe0, 0x2c, 0x70, 0x0b, 0xcc, 0x2f, 0x69, 0x1c, 0xfa, 0xa1, 0x97, 0x58,
-	0xf5, 0x6e, 0xb9, 0x5f, 0x25, 0xdb, 0x7d, 0xef, 0x9b, 0x12, 0xe8, 0xd2, 0x34, 0xf8, 0x75, 0xd0,
-	0x85, 0x01, 0x12, 0x0b, 0x49, 0xd2, 0x37, 0x9e, 0x37, 0xca, 0x1c, 0x81, 0x3f, 0x80, 0x5a, 0x71,
-	0xfd, 0x8a, 0x46, 0xca, 0xce, 0xb7, 0x76, 0x12, 0x64, 0xd5, 0x82, 0xfa, 0x31, 0x8d, 0x22, 0x3f,
-	0x2c, 0xda, 0x2e, 0xc8, 0x1f, 0xd3, 0xe8, 0x0a, 0xb9, 0xf2, 0x55, 0x72, 0xad, 0x0c, 0xf6, 0xaf,
-	0xe6, 0xef, 0x34, 0x8e, 0xfe, 0xa1, 0xf1, 0xc3, 0x4b, 0x61, 0x4b, 0x7f, 0x27, 0xac, 0xa2, 0x55,
-	0x80, 0x7b, 0x8f, 0x41, 0xb7, 0x69, 0x3a, 0xff, 0xfc, 0xdf, 0x68, 0xf2, 0x1f, 0xef, 0xba, 0xfd,
-	0x2e, 0x54, 0xb7, 0x3f, 0x03, 0x0c, 0x50, 0x39, 0x9d, 0x11, 0xe7, 0xe4, 0xbd, 0xe6, 0x1e, 0x36,
-	0x41, 0xb3, 0xa7, 0xd3, 0x49, 0x13, 0xe1, 0x2a, 0xe8, 0xce, 0xc9, 0xec, 0xf0, 0x7e, 0xb3, 0x84,
-	0x6b, 0x60, 0x8c, 0x27, 0xd3, 0x87, 0x62, 0x53, 0x16, 0x68, 0xdb, 0x39, 0x79, 0x48, 0x3e, 0x6d,
-	0x6a, 0xb7, 0xdf, 0x80, 0xda, 0x33, 0x1f, 0x28, 0x5c, 0x07, 0xf3, 0xd1, 0xfb, 0xce, 0xe4, 0xc8,
-	0x9d, 0x8e, 0x9b, 0x7b, 0xb8, 0x09, 0xf5, 0xf1, 0x74, 0x32, 0x99, 0x7e, 0x72, 0xea, 0x8e, 0xc9,
-	0xf4, 0xb8, 0x89, 0xec, 0xbb, 0x4f, 0x36, 0x6d, 0xf4, 0xd3, 0xa6, 0x8d, 0x7e, 0xdf, 0xb4, 0xd1,
-	0x8f, 0x7f, 0xb4, 0x11, 0x1c, 0xf8, 0x5c, 0x11, 0x16, 0x9f, 0x0e, 0x3f, 0xf4, 0x14, 0xef, 0xcf,
-	0x74, 0xf9, 0xeb, 0x3d, 0xab, 0xc8, 0x97, 0xe5, 0xcd, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0x28,
-	0x10, 0xf8, 0xb3, 0x8a, 0x07, 0x00, 0x00,
+	0x0c, 0x34, 0xe3, 0x71, 0xb6, 0x1b, 0x2a, 0xd8, 0x5e, 0x38, 0x79, 0x66, 0xde, 0xf7, 0xde, 0x7c,
+	0xef, 0x7b, 0x9f, 0x6d, 0xa8, 0xad, 0xf8, 0x82, 0x05, 0x83, 0x28, 0xe6, 0x29, 0xc7, 0x8d, 0xc7,
+	0x94, 0x79, 0x2c, 0x1e, 0xd0, 0xc8, 0x77, 0xb3, 0x51, 0xeb, 0x25, 0x8f, 0x7b, 0x5c, 0x46, 0x86,
+	0x62, 0x95, 0x83, 0x5a, 0xaf, 0x79, 0x9c, 0x7b, 0x01, 0x1b, 0xd2, 0xc8, 0x1f, 0xd2, 0x30, 0xe4,
+	0x29, 0x4d, 0x7d, 0x1e, 0x26, 0x2a, 0xda, 0x51, 0x51, 0xb9, 0x3b, 0x3b, 0x5f, 0x0e, 0x53, 0x7f,
+	0xc5, 0x92, 0x94, 0xae, 0x22, 0x05, 0x68, 0xef, 0x02, 0x16, 0xe7, 0xb1, 0xac, 0x90, 0xc7, 0x7b,
+	0xbf, 0x22, 0x30, 0x3f, 0x66, 0xeb, 0x4f, 0x69, 0x70, 0xce, 0x70, 0x13, 0xca, 0x5f, 0xb1, 0xb5,
+	0x85, 0xba, 0xa8, 0x5f, 0x25, 0x62, 0x89, 0x87, 0x50, 0xc9, 0xdc, 0x74, 0x1d, 0x31, 0xab, 0xd4,
+	0x45, 0xfd, 0xfd, 0x91, 0x35, 0xb8, 0xc2, 0x79, 0x20, 0xf3, 0x66, 0xeb, 0x88, 0x11, 0x3d, 0x13,
+	0x0f, 0x7c, 0x03, 0xf4, 0xcc, 0x4d, 0xd2, 0xd8, 0x2a, 0xcb, 0x22, 0x5a, 0x76, 0x9a, 0xc6, 0xf8,
+	0x65, 0x51, 0xe5, 0x8c, 0xf3, 0xc0, 0xd2, 0xba, 0xa8, 0x6f, 0x12, 0x3d, 0xb3, 0x39, 0x0f, 0xf0,
+	0x01, 0x18, 0x99, 0xeb, 0x87, 0xe9, 0xe1, 0x7d, 0x4b, 0xef, 0xa2, 0x7e, 0x99, 0x54, 0x32, 0x47,
+	0xec, 0xf0, 0xab, 0x50, 0xcd, 0xdc, 0x65, 0xc0, 0xa9, 0x08, 0x55, 0xba, 0xa8, 0x8f, 0x88, 0x99,
+	0x8d, 0xf3, 0x3d, 0xbe, 0x09, 0x66, 0xe6, 0x9e, 0xf9, 0x21, 0x8d, 0xd7, 0x96, 0xd1, 0x45, 0xfd,
+	0x3a, 0x31, 0x32, 0x5b, 0x6e, 0xdf, 0x31, 0x9f, 0xfe, 0xd0, 0x41, 0x4f, 0x7f, 0xec, 0xa0, 0xde,
+	0x37, 0x08, 0xca, 0x13, 0xee, 0x61, 0x1b, 0xaa, 0x5b, 0x45, 0x64, 0x5f, 0xb5, 0x51, 0x6b, 0x90,
+	0x4b, 0x32, 0x28, 0x24, 0x19, 0xcc, 0x0a, 0x84, 0x6d, 0x3e, 0xb9, 0xe8, 0xec, 0x7d, 0xfb, 0x47,
+	0x07, 0x91, 0xcb, 0x34, 0xfc, 0x00, 0x2a, 0x4b, 0x9f, 0x05, 0x8b, 0xc4, 0x2a, 0x75, 0xcb, 0xfd,
+	0xda, 0xe8, 0x60, 0x47, 0x83, 0x42, 0x3e, 0x5b, 0x13, 0xd9, 0x44, 0x81, 0x7b, 0x3f, 0x21, 0x30,
+	0x4e, 0x23, 0x1a, 0x12, 0xb6, 0xc4, 0x0f, 0xc0, 0x4c, 0x63, 0x3a, 0x67, 0xae, 0xbf, 0x90, 0x2c,
+	0xea, 0x76, 0x4b, 0x60, 0x7f, 0xbb, 0xe8, 0x18, 0x33, 0x71, 0xee, 0x1c, 0x6d, 0x2e, 0x97, 0xc4,
+	0x90, 0x58, 0x67, 0x81, 0xef, 0x81, 0x91, 0x44, 0x34, 0x14, 0x59, 0x25, 0x99, 0x65, 0xa9, 0xac,
+	0x8a, 0x28, 0x2c, 0x93, 0xd4, 0x8a, 0x54, 0x04, 0xd0, 0x59, 0x88, 0x9b, 0x62, 0xb6, 0xcc, 0x47,
+	0x56, 0x96, 0x23, 0x6b, 0xed, 0xd0, 0x55, 0x9c, 0xe4, 0xd0, 0x8c, 0x38, 0x5f, 0xf4, 0x5c, 0x30,
+	0x3e, 0x89, 0xf9, 0x9c, 0x25, 0x09, 0x7e, 0x1d, 0xea, 0x09, 0x8b, 0x33, 0x7f, 0xce, 0xdc, 0x90,
+	0xae, 0x98, 0x72, 0x43, 0x4d, 0x9d, 0x9d, 0xd0, 0x15, 0xc3, 0xf7, 0x40, 0x4b, 0xa9, 0x77, 0x4d,
+	0x3d, 0x24, 0xb4, 0xf7, 0xbb, 0x06, 0x9a, 0xb8, 0xf9, 0x7f, 0x94, 0xe2, 0x0d, 0xd8, 0xe7, 0x11,
+	0xcb, 0xdd, 0x9e, 0xb7, 0x92, 0x7b, 0xb2, 0xb1, 0x3d, 0x95, 0xcd, 0xbc, 0x0b, 0x10, 0xb3, 0x25,
+	0x8b, 0x59, 0x38, 0x67, 0x89, 0xa5, 0xc9, 0x96, 0x5e, 0x79, 0xbe, 0x66, 0xaa, 0xa3, 0x67, 0xf0,
+	0xf8, 0x16, 0xe8, 0xcb, 0x40, 0x68, 0x21, 0x1c, 0xdc, 0xb0, 0x1b, 0x8a, 0x95, 0x3e, 0x16, 0x87,
+	0x24, 0x8f, 0xe1, 0x47, 0x00, 0x49, 0x4a, 0xe3, 0xd4, 0x15, 0xa6, 0x92, 0x86, 0xbe, 0xb6, 0x0d,
+	0x65, 0x9e, 0x88, 0xe0, 0xf7, 0xc0, 0x2c, 0xde, 0x5d, 0xe9, 0xfb, 0xda, 0xe8, 0xe6, 0x3f, 0x4a,
+	0x1c, 0x29, 0x40, 0x5e, 0xe1, 0x7b, 0x51, 0x61, 0x9b, 0xb4, 0x9d, 0x9a, 0x79, 0xed, 0xa9, 0xe1,
+	0x3b, 0xa0, 0x05, 0xdc, 0x4b, 0xac, 0xaa, 0x4c, 0xc1, 0x3b, 0x29, 0x13, 0xee, 0x15, 0x68, 0x81,
+	0xc2, 0x77, 0xc1, 0x88, 0x72, 0x13, 0x59, 0x20, 0x09, 0xee, 0xca, 0xa8, 0x2c, 0x46, 0x0a, 0x18,
+	0xbe, 0x03, 0xa0, 0x96, 0x62, 0xb0, 0x35, 0x31, 0x1e, 0xbb, 0xb1, 0xb9, 0xe8, 0x54, 0x15, 0xd2,
+	0x39, 0x22, 0x55, 0x05, 0x70, 0x16, 0xb8, 0x05, 0xe6, 0xd7, 0x34, 0x0e, 0xfd, 0xd0, 0x4b, 0xac,
+	0x7a, 0xb7, 0xdc, 0xaf, 0x92, 0xed, 0xbe, 0xf7, 0x5d, 0x09, 0x74, 0x69, 0x1a, 0xfc, 0x26, 0xe8,
+	0xc2, 0x00, 0x89, 0x85, 0x24, 0xe9, 0x1b, 0xcf, 0x1b, 0x65, 0x8e, 0xc0, 0x1f, 0x41, 0xad, 0xb8,
+	0x7e, 0x45, 0x23, 0x65, 0xe7, 0x5b, 0x3b, 0x09, 0xb2, 0x6a, 0x41, 0xfd, 0x98, 0x46, 0x91, 0x1f,
+	0x16, 0x6d, 0x17, 0xe4, 0x8f, 0x69, 0x74, 0x85, 0x5c, 0xf9, 0x2a, 0xb9, 0x56, 0x06, 0xfb, 0x57,
+	0xf3, 0x77, 0x1a, 0x47, 0xff, 0xd1, 0xf8, 0xe1, 0xa5, 0xb0, 0xa5, 0x7f, 0x13, 0x56, 0xd1, 0x2a,
+	0xc0, 0xbd, 0xc7, 0xa0, 0xdb, 0x34, 0x9d, 0x7f, 0xf9, 0x22, 0x9a, 0xbc, 0xd0, 0x5d, 0x68, 0x7b,
+	0xd7, 0xed, 0xf7, 0xa1, 0xba, 0xfd, 0x19, 0x60, 0x80, 0xca, 0xe9, 0x8c, 0x38, 0x27, 0x1f, 0x34,
+	0xf7, 0xb0, 0x09, 0x9a, 0x3d, 0x9d, 0x4e, 0x9a, 0x08, 0x57, 0x41, 0x77, 0x4e, 0x66, 0x87, 0xf7,
+	0x9b, 0x25, 0x5c, 0x03, 0x63, 0x3c, 0x99, 0x3e, 0x14, 0x9b, 0xb2, 0x40, 0xdb, 0xce, 0xc9, 0x43,
+	0xf2, 0x79, 0x53, 0xbb, 0xfd, 0x16, 0xd4, 0x9e, 0xf9, 0x40, 0xe1, 0x3a, 0x98, 0x8f, 0x3e, 0x74,
+	0x26, 0x47, 0xee, 0x74, 0xdc, 0xdc, 0xc3, 0x4d, 0xa8, 0x8f, 0xa7, 0x93, 0xc9, 0xf4, 0xb3, 0x53,
+	0x77, 0x4c, 0xa6, 0xc7, 0x4d, 0x64, 0xdf, 0x7d, 0xb2, 0x69, 0xa3, 0x5f, 0x36, 0x6d, 0xf4, 0xe7,
+	0xa6, 0x8d, 0x7e, 0xfe, 0xab, 0x8d, 0xe0, 0xc0, 0xe7, 0x8a, 0xb0, 0xf8, 0x74, 0xf8, 0xa1, 0xa7,
+	0x78, 0x7f, 0xa1, 0xcb, 0x5f, 0xef, 0x59, 0x45, 0xbe, 0x2c, 0x6f, 0xff, 0x1d, 0x00, 0x00, 0xff,
+	0xff, 0xc9, 0x46, 0x02, 0x11, 0x8a, 0x07, 0x00, 0x00,
 }
diff --git a/model/proto/model.proto b/model/proto/model.proto
index 625e30b3df9..3bce8a1ac5a 100644
--- a/model/proto/model.proto
+++ b/model/proto/model.proto
@@ -155,6 +155,6 @@ message Trace {
 message Batch {
     repeated Span spans = 1;
     Process process = 2 [
-      (gogoproto.nullable) = false
+      (gogoproto.nullable) = true
     ];
 }