Repository: jaegertracing/jaeger

Issue:
Replace use of model/converter/thrift/zipkin
This package was copied into OTEL Collector Contrib in https://github.com/open-telemetry/opentelemetry-collector-contrib/pull/37796.

Objective is to delete this package in Jaeger and replace its usage with the functions from OTEL Contrib.
```
$ rg model/converter/thrift/zipkin
cmd/agent/app/reporter/grpc/reporter.go
22:	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"

cmd/collector/app/handler/zipkin_receiver_test.go
29:	zipkinthrift "github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"

cmd/collector/app/handler/thrift_span_handler.go
18:	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"

internal/storage/v1/kafka/unmarshaller.go
14:	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"

internal/storage/v1/kafka/marshalling_test.go
14:	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"
```

Discussion:
@shuraih775: i am working on this issue@shuraih775: I have replaced all occurrences of "github.com/jaegertracing/jaeger/model/converter/thrift/zipkin" with "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin" at five locations and removed the zipkin directory from model/converter/thrift.

Would this be the correct approach?@yurishkuro: probably, please open a PR@shuraih775: Actually, "github.com/jaegertracing/jaeger/model/converter/thrift/zipkin" is to be replaced with  "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin/zipkinthriftconverter".
Also there was a slight change in the SerializeThrift implemetation of open telemetry from the one that existed in jaeger.
There was error handling added to SerializeThrift function.
Made necessary changes related to the new implementation wherever required.@yurishkuro: PR please, I can't discuss what I don't see. @shuraih775: when i ran "make lint" i got error telling  " ./idl/internal/tools/go.mod                        Go version: 1.23 *** needs update to 1.24 ***" but when i updated the go version and ran "make lint" again i got a lot of errors and "make test" also failed. Do i have to fix that?
Note: The PR doesn't contains the thing mentioned above. 

Solution patch:
diff --git a/cmd/collector/app/handler/thrift_span_handler.go b/cmd/collector/app/handler/thrift_span_handler.go
index 76b40fc5..978a0a5b 100644
--- a/cmd/collector/app/handler/thrift_span_handler.go
+++ b/cmd/collector/app/handler/thrift_span_handler.go
@@ -7,6 +7,7 @@ package handler
 import (
 	"context"
 
+	zipkin "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin/zipkinthriftconverter"
 	"go.uber.org/zap"
 
 	"github.com/jaegertracing/jaeger-idl/model/v1"
@@ -15,7 +16,6 @@ import (
 	"github.com/jaegertracing/jaeger/cmd/collector/app/processor"
 	zipkinS "github.com/jaegertracing/jaeger/cmd/collector/app/sanitizer/zipkin"
 	jConv "github.com/jaegertracing/jaeger/model/converter/thrift/jaeger"
-	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"
 )
 
 // SubmitBatchOptions are passed to Submit methods of the handlers.
diff --git a/go.mod b/go.mod
index 3be1a101..33f33c75 100644
--- a/go.mod
+++ b/go.mod
@@ -19,7 +19,6 @@ require (
 	github.com/gogo/protobuf v1.3.2
 	github.com/gorilla/handlers v1.5.2
 	github.com/gorilla/mux v1.8.1
-	github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.1
 	github.com/jaegertracing/jaeger-idl v0.5.0
 	github.com/kr/pretty v0.3.1
 	github.com/olivere/elastic v6.2.37+incompatible
@@ -208,7 +207,7 @@ require (
 	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/status v0.122.0 // indirect
 	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/azure v0.122.0 // indirect
 	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/prometheus v0.122.0 // indirect
-	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin v0.122.0 // indirect
+	github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin v0.122.0
 	github.com/opentracing/opentracing-go v1.2.0 // indirect
 	github.com/openzipkin/zipkin-go v0.4.3 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
diff --git a/go.sum b/go.sum
index a8512916..b52aee25 100644
--- a/go.sum
+++ b/go.sum
@@ -284,8 +284,6 @@ github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWm
 github.com/gorilla/websocket v1.5.0/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc h1:GN2Lv3MGO7AS6PrRoT6yV5+wkrOpcszoIsO4+4ds248=
 github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc/go.mod h1:+JKpmjMGhpgPL+rXZ5nsZieVzvarn86asRlBg4uNGnk=
-github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.1 h1:KcFzXwzM/kGhIRHvc8jdixfIJjVzuUJdnv+5xsPutog=
-github.com/grpc-ecosystem/go-grpc-middleware/v2 v2.3.1/go.mod h1:qOchhhIlmRcqk/O9uCo/puJlyo07YINaIqdZfZG3Jkc=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1 h1:e9Rjr40Z98/clHv5Yg79Is0NtosR5LXRvdr7o/6NwbA=
 github.com/grpc-ecosystem/grpc-gateway/v2 v2.26.1/go.mod h1:tIxuGz/9mpox++sgp9fJjHO0+q1X9/UOWd798aAm22M=
 github.com/hailocab/go-hostpool v0.0.0-20160125115350-e80d13ce29ed h1:5upAirOpQc1Q53c0bnx2ufif5kANL7bfZWcc6VJWJd8=
diff --git a/internal/storage/v1/kafka/unmarshaller.go b/internal/storage/v1/kafka/unmarshaller.go
index 2f678bc2..022be041 100644
--- a/internal/storage/v1/kafka/unmarshaller.go
+++ b/internal/storage/v1/kafka/unmarshaller.go
@@ -9,9 +9,9 @@ import (
 
 	"github.com/gogo/protobuf/jsonpb"
 	"github.com/gogo/protobuf/proto"
+	zipkin "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin/zipkinthriftconverter"
 
 	"github.com/jaegertracing/jaeger-idl/model/v1"
-	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"
 )
 
 // Unmarshaller decodes a byte array to a span
diff --git a/model/converter/thrift/zipkin/deserialize.go b/model/converter/thrift/zipkin/deserialize.go
deleted file mode 100644
index 931bc314..00000000
--- a/model/converter/thrift/zipkin/deserialize.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2018 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"context"
-
-	"github.com/apache/thrift/lib/go/thrift"
-
-	"github.com/jaegertracing/jaeger-idl/thrift-gen/zipkincore"
-)
-
-// SerializeThrift is only used in tests.
-func SerializeThrift(ctx context.Context, spans []*zipkincore.Span) []byte {
-	t := thrift.NewTMemoryBuffer()
-	p := thrift.NewTBinaryProtocolConf(t, &thrift.TConfiguration{})
-	p.WriteListBegin(ctx, thrift.STRUCT, len(spans))
-	for _, s := range spans {
-		s.Write(ctx, p)
-	}
-	p.WriteListEnd(ctx)
-	return t.Buffer.Bytes()
-}
-
-// DeserializeThrift decodes Thrift bytes to a list of spans.
-func DeserializeThrift(ctx context.Context, b []byte) ([]*zipkincore.Span, error) {
-	buffer := thrift.NewTMemoryBuffer()
-	buffer.Write(b)
-
-	transport := thrift.NewTBinaryProtocolConf(buffer, &thrift.TConfiguration{})
-	_, size, err := transport.ReadListBegin(ctx) // Ignore the returned element type
-	if err != nil {
-		return nil, err
-	}
-
-	// We don't depend on the size returned by ReadListBegin to preallocate the array because it
-	// sometimes returns a nil error on bad input and provides an unreasonably large int for size
-	var spans []*zipkincore.Span
-	for i := 0; i < size; i++ {
-		zs := &zipkincore.Span{}
-		if err = zs.Read(ctx, transport); err != nil {
-			return nil, err
-		}
-		spans = append(spans, zs)
-	}
-
-	return spans, nil
-}
diff --git a/model/converter/thrift/zipkin/doc.go b/model/converter/thrift/zipkin/doc.go
deleted file mode 100644
index 4f47098f..00000000
--- a/model/converter/thrift/zipkin/doc.go
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-// Package zipkin allows converting model.Trace to/from zipkin.thrift model.
-package zipkin
diff --git a/model/converter/thrift/zipkin/fixtures/domain_01.json b/model/converter/thrift/zipkin/fixtures/domain_01.json
deleted file mode 100644
index 0efa12f2..00000000
--- a/model/converter/thrift/zipkin/fixtures/domain_01.json
+++ /dev/null
@@ -1,102 +0,0 @@
-{
-  "spans": [
-    {
-      "traceId": "AAAAAAAAAAAAAAAAAAAAAQ==",
-      "spanId": "AAAAAAAAAAI=",
-      "operationName": "test-general-conversion",
-      "startTime": "2017-01-26T16:46:31.639875-05:00",
-      "process": {
-        "serviceName": "service-x"
-      },
-      "logs": [
-        {
-          "timestamp": "1970-01-01T00:00:00-00:00",
-          "fields": [
-            {
-              "key": "event",
-              "vStr": "some-event"
-            }
-          ]
-        },
-        {
-          "timestamp": "2017-01-26T16:46:31.639875-05:00",
-          "fields": [
-            {
-              "key": "x",
-              "vStr": "y"
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "traceId": "AAAAAAAAAAAAAAAAAAAAAQ==",
-      "spanId": "AAAAAAAAAAI=",
-      "operationName": "some-operation",
-      "startTime": "1970-01-01T00:00:00-00:00",
-      "tags": [
-        {
-          "key": "peer.service",
-          "vType": "STRING",
-          "vStr": "service-y"
-        },
-        {
-          "key": "peer.ipv4",
-          "vType": "INT64",
-          "vInt64": 23456
-        },
-        {
-          "key": "peer.port",
-          "vType": "INT64",
-          "vInt64": 80
-        },
-        {
-          "key": "span.kind",
-          "vType": "STRING",
-          "vStr": "client"
-        }
-      ],
-      "process": {
-        "serviceName": "service-x"
-      }
-    },
-    {
-      "traceId": "AAAAAAAAAAIAAAAAAAAAAQ==",
-      "spanId": "AAAAAAAAAAM=",
-      "operationName": "some-operation",
-      "references": [
-        {
-          "refType": "CHILD_OF",
-          "traceId": "AAAAAAAAAAIAAAAAAAAAAQ==",
-          "spanId": "AAAAAAAAAAI="
-        }
-      ],
-      "startTime": "1970-01-01T00:00:00-00:00",
-      "tags": [
-        {
-          "key": "peer.service",
-          "vType": "STRING",
-          "vStr": "service-x"
-        },
-        {
-          "key": "peer.ipv4",
-          "vType": "INT64",
-          "vInt64": 23456
-        },
-        {
-          "key": "peer.ipv6",
-          "vType": "BINARY",
-          "vBinary": "MjAwMTpkYjg6OmMwMDE="
-        },
-        {
-          "key": "span.kind",
-          "vType": "STRING",
-          "vStr": "server"
-        }
-      ],
-      "process": {
-        "serviceName": "service-y"
-      }
-    }
-  ]
-}
diff --git a/model/converter/thrift/zipkin/fixtures/domain_02.json b/model/converter/thrift/zipkin/fixtures/domain_02.json
deleted file mode 100644
index 2a20e96b..00000000
--- a/model/converter/thrift/zipkin/fixtures/domain_02.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-  "spans": [
-    {
-      "traceId": "AAAAAAAAAAAAAAAAAAAAAQ==",
-      "spanId": "AAAAAAAAAAI=",
-      "operationName": "test-process-tags",
-      "startTime": "1970-01-01T00:00:00-00:00",
-      "process": {
-        "serviceName": "service-x",
-        "tags": [
-          {
-            "key": "hostname",
-            "vStr": "some-host.com"
-          },
-          {
-            "key": "ip",
-            "vType": "INT64",
-            "vInt64": 12345
-          },
-          {
-            "key": "jaeger.version",
-            "vStr": "Go-1.1"
-          }
-        ]
-      },
-      "tags": [
-        {
-          "key": "component",
-          "vStr": "some-component"
-        }
-      ]
-    }
-  ]
-}
diff --git a/model/converter/thrift/zipkin/fixtures/domain_03.json b/model/converter/thrift/zipkin/fixtures/domain_03.json
deleted file mode 100644
index 6a543ba6..00000000
--- a/model/converter/thrift/zipkin/fixtures/domain_03.json
+++ /dev/null
@@ -1,71 +0,0 @@
-{
-  "spans": [
-    {
-      "traceId": "AAAAAAAAAAAAAAAAAAAAAQ==",
-      "spanId": "AAAAAAAAAAI=",
-      "flags": 2,
-      "operationName": "test-custom-tags",
-      "startTime": "1970-01-01T00:00:00-00:00",
-      "duration": "5000ns",
-      "process": {
-        "serviceName": "service-x"
-      },
-      "tags": [
-          {
-            "key": "bool",
-            "vType": "BOOL",
-            "vBool": true
-          },
-          {
-            "key": "bytes",
-            "vType": "BINARY",
-            "vBinary": "c29tZS1ob3N0LmNvbQ=="
-          },
-          {
-            "key": "i16",
-            "vType": "INT64",
-            "vInt64": 12345
-          },
-          {
-            "key": "i16_bad_value",
-            "vStr": "Cannot parse Zipkin value AQ==: unexpected EOF"
-          },
-          {
-            "key": "i32",
-            "vType": "INT64",
-            "vInt64": 12345
-          },
-          {
-            "key": "i32_bad_value",
-            "vStr": "Cannot parse Zipkin value AQ==: unexpected EOF"
-          },
-          {
-            "key": "i64",
-            "vType": "INT64",
-            "vInt64": 12345
-          },
-          {
-            "key": "i64_bad_value",
-            "vStr": "Cannot parse Zipkin value AQ==: unexpected EOF"
-          },
-          {
-            "key": "double",
-            "vType": "FLOAT64",
-            "vFloat64": 12345
-          },
-          {
-            "key": "double_bad_value",
-            "vStr": "Cannot parse Zipkin value AQ==: unexpected EOF"
-          },
-          {
-            "key": "string",
-            "vStr": "some-host.com"
-          },
-          {
-            "key": "span.kind",
-            "vStr": "server"
-          }
-      ]
-    }
-  ]
-}
diff --git a/model/converter/thrift/zipkin/fixtures/zipkin_01.json b/model/converter/thrift/zipkin/fixtures/zipkin_01.json
deleted file mode 100644
index eb7fed78..00000000
--- a/model/converter/thrift/zipkin/fixtures/zipkin_01.json
+++ /dev/null
@@ -1,76 +0,0 @@
-[
-  {
-    "trace_id": 1,
-    "id": 2,
-    "name": "test-general-conversion",
-    "timestamp": 1485467191639875,
-    "annotations": [
-      {
-        "value": "some-event",
-        "host": {
-          "service_name": "service-x"
-        }
-      },
-      {
-        "value": ""
-      },
-      {
-        "timestamp": 1485467191639875,
-        "value": "{\"x\":\"y\"}"
-      }
-    ],
-    "binary_annotations": [
-        {
-            "key": "ca"
-        }
-    ]
-  },
-  {
-    "trace_id": 1,
-    "id": 2,
-    "name": "some-operation",
-    "annotations": [
-      {
-        "value": "cs",
-        "host": {
-          "service_name": "service-x"
-        }
-      }
-    ],
-    "binary_annotations": [
-        {
-            "key": "sa",
-            "host": {
-                "service_name": "service-y",
-                "ipv4": 23456,
-                "port": 80
-            }
-        }
-    ]
-  },
-  {
-    "trace_id": 1,
-    "id": 3,
-    "parent_id": 2,
-    "name": "some-operation",
-    "trace_id_high": 2,
-    "annotations": [
-      {
-        "value": "sr",
-        "host": {
-          "service_name": "service-y"
-        }
-      }
-    ],
-    "binary_annotations": [
-        {
-            "key": "ca",
-            "host": {
-                "service_name": "service-x",
-                "ipv4": 23456,
-                "ipv6": "MjAwMTpkYjg6OmMwMDE="
-            }
-        }
-    ]
-  }
-]
diff --git a/model/converter/thrift/zipkin/fixtures/zipkin_02.json b/model/converter/thrift/zipkin/fixtures/zipkin_02.json
deleted file mode 100644
index 56db82b9..00000000
--- a/model/converter/thrift/zipkin/fixtures/zipkin_02.json
+++ /dev/null
@@ -1,28 +0,0 @@
-[
-  {
-    "trace_id": 1,
-    "id": 2,
-    "name": "test-process-tags",
-    "binary_annotations": [
-      {
-        "key": "lc",
-        "value": "c29tZS1jb21wb25lbnQ=",
-        "annotation_type": "STRING",
-        "host": {
-          "service_name": "service-x",
-          "ipv4": 12345
-        }
-      },
-      {
-        "key": "jaegerClient",
-        "value": "R28tMS4x",
-        "annotation_type": "STRING"
-      },
-      {
-        "key": "jaeger.hostname",
-        "value": "c29tZS1ob3N0LmNvbQ==",
-        "annotation_type": "STRING"
-      }
-    ]
-  }
-]
diff --git a/model/converter/thrift/zipkin/fixtures/zipkin_03.json b/model/converter/thrift/zipkin/fixtures/zipkin_03.json
deleted file mode 100644
index 6aed61d2..00000000
--- a/model/converter/thrift/zipkin/fixtures/zipkin_03.json
+++ /dev/null
@@ -1,74 +0,0 @@
-[
-  {
-    "trace_id": 1,
-    "id": 2,
-    "debug": true,
-    "name": "test-custom-tags",
-    "duration": 5,
-    "annotations": [
-      {
-        "value": "sr",
-        "host": {
-          "service_name": "service-x"
-        }
-      }
-    ],
-    "binary_annotations": [
-      {
-        "key": "bool",
-        "value": "AQ==",
-        "annotation_type": "BOOL"
-      },
-      {
-        "key": "bytes",
-        "value": "c29tZS1ob3N0LmNvbQ==",
-        "annotation_type": "BYTES"
-      },
-      {
-        "key": "i16",
-        "value": "MDk=",
-        "annotation_type": "I16"
-      },
-      {
-        "key": "i16_bad_value",
-        "value": "AQ==",
-        "annotation_type": "I16"
-      },
-      {
-        "key": "i32",
-        "value": "AAAwOQ==",
-        "annotation_type": "I32"
-      },
-      {
-        "key": "i32_bad_value",
-        "value": "AQ==",
-        "annotation_type": "I32"
-      },
-      {
-        "key": "i64",
-        "value": "AAAAAAAAMDk=",
-        "annotation_type": "I64"
-      },
-      {
-        "key": "i64_bad_value",
-        "value": "AQ==",
-        "annotation_type": "I64"
-      },
-      {
-        "key": "double",
-        "value": "QMgcgAAAAAA=",
-        "annotation_type": "DOUBLE"
-      },
-      {
-        "key": "double_bad_value",
-        "value": "AQ==",
-        "annotation_type": "DOUBLE"
-      },
-      {
-        "key": "string",
-        "value": "c29tZS1ob3N0LmNvbQ==",
-        "annotation_type": "STRING"
-      }
-    ]
-  }
-]
diff --git a/model/converter/thrift/zipkin/process_hashtable.go b/model/converter/thrift/zipkin/process_hashtable.go
deleted file mode 100644
index 5de1a695..00000000
--- a/model/converter/thrift/zipkin/process_hashtable.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"github.com/jaegertracing/jaeger-idl/model/v1"
-)
-
-type processHashtable struct {
-	processes map[uint64][]*model.Process
-	extHash   func(*model.Process) uint64
-}
-
-func newProcessHashtable() *processHashtable {
-	processes := make(map[uint64][]*model.Process)
-	return &processHashtable{processes: processes}
-}
-
-func (ph processHashtable) hash(process *model.Process) uint64 {
-	if ph.extHash != nil {
-		// for testing collisions
-		return ph.extHash(process)
-	}
-	hc, _ := model.HashCode(process)
-	return hc
-}
-
-// add checks if identical Process already exists in the hash table and returns it.
-// Otherwise it adds process to the table and returns it.
-func (ph processHashtable) add(process *model.Process) *model.Process {
-	hash := ph.hash(process)
-	if pp, ok := ph.processes[hash]; ok {
-		for _, p := range pp {
-			if p.Equal(process) {
-				return p // reuse existing Process object
-			}
-		}
-		pp = append(pp, process)
-		ph.processes[hash] = pp
-	} else {
-		ph.processes[hash] = []*model.Process{process}
-	}
-	return process
-}
diff --git a/model/converter/thrift/zipkin/to_domain.go b/model/converter/thrift/zipkin/to_domain.go
deleted file mode 100644
index 970f5732..00000000
--- a/model/converter/thrift/zipkin/to_domain.go
+++ /dev/null
@@ -1,422 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"go.opentelemetry.io/otel/trace"
-
-	"github.com/jaegertracing/jaeger-idl/model/v1"
-	"github.com/jaegertracing/jaeger-idl/thrift-gen/zipkincore"
-)
-
-const (
-	// UnknownServiceName is serviceName we give to model.Process if we cannot find it anywhere in a Zipkin span
-	UnknownServiceName = "unknown-service-name"
-	component          = "component"
-	peerservice        = "peer.service"
-	peerHostIPv4       = "peer.ipv4"
-	peerHostIPv6       = "peer.ipv6"
-	peerPort           = "peer.port"
-)
-
-var (
-	coreAnnotations = map[string]string{
-		zipkincore.SERVER_RECV: trace.SpanKindServer.String(),
-		zipkincore.SERVER_SEND: trace.SpanKindServer.String(),
-		zipkincore.CLIENT_RECV: trace.SpanKindClient.String(),
-		zipkincore.CLIENT_SEND: trace.SpanKindClient.String(),
-	}
-
-	// Some tags on Zipkin spans really describe the process emitting them rather than an individual span.
-	// Once all clients are upgraded to use native Jaeger model, this won't be happenning, but for now
-	// we remove these tags from the span and store them in the Process.
-	processTagAnnotations = map[string]string{
-		"jaegerClient":    "jaeger.version", // transform this tag name to client.version
-		"jaeger.hostname": "hostname",       // transform this tag name to hostname
-		"jaeger.version":  "jaeger.version", // keep this key as is
-	}
-
-	trueByteSlice = []byte{1}
-
-	// DefaultLogFieldKey is the log field key which translates directly into Zipkin's Annotation.Value,
-	// provided it's the only field in the log.
-	// In all other cases the fields are encoded into Annotation.Value as JSON string.
-	// TODO move to domain model
-	DefaultLogFieldKey = "event"
-
-	// IPTagName is the Jaeger tag name for an IPv4/IPv6 IP address.
-	// TODO move to domain model
-	IPTagName = "ip"
-)
-
-// ToDomain transforms a trace in zipkin.thrift format into model.Trace.
-// The transformation assumes that all spans have the same Trace ID.
-// A valid model.Trace is always returned, even when there are errors.
-// The errors are more of an "fyi", describing issues in the data.
-// TODO consider using different return type instead of `error`.
-func ToDomain(zSpans []*zipkincore.Span) (*model.Trace, error) {
-	return toDomain{}.ToDomain(zSpans)
-}
-
-// ToDomainSpan transforms a span in zipkin.thrift format into model.Span.
-// A valid model.Span is always returned, even when there are errors.
-// The errors are more of an "fyi", describing issues in the data.
-// TODO consider using different return type instead of `error`.
-func ToDomainSpan(zSpan *zipkincore.Span) ([]*model.Span, error) {
-	return toDomain{}.ToDomainSpans(zSpan)
-}
-
-type toDomain struct{}
-
-func (td toDomain) ToDomain(zSpans []*zipkincore.Span) (*model.Trace, error) {
-	var errs []error
-	processes := newProcessHashtable()
-	trc := &model.Trace{}
-	for _, zSpan := range zSpans {
-		jSpans, err := td.ToDomainSpans(zSpan)
-		if err != nil {
-			errs = append(errs, err)
-		}
-		for _, jSpan := range jSpans {
-			// remove duplicate Process instances
-			jSpan.Process = processes.add(jSpan.Process)
-			trc.Spans = append(trc.Spans, jSpan)
-		}
-	}
-	return trc, errors.Join(errs...)
-}
-
-func (td toDomain) ToDomainSpans(zSpan *zipkincore.Span) ([]*model.Span, error) {
-	jSpans := td.transformSpan(zSpan)
-	jProcess, err := td.generateProcess(zSpan)
-	for _, jSpan := range jSpans {
-		jSpan.Process = jProcess
-	}
-	return jSpans, err
-}
-
-func (toDomain) findAnnotation(zSpan *zipkincore.Span, value string) *zipkincore.Annotation {
-	for _, ann := range zSpan.Annotations {
-		if ann.Value == value {
-			return ann
-		}
-	}
-	return nil
-}
-
-// transformSpan transforms a zipkin span into a Jaeger span
-func (td toDomain) transformSpan(zSpan *zipkincore.Span) []*model.Span {
-	tags := td.getTags(zSpan.BinaryAnnotations, td.isSpanTag)
-	if spanKindTag, ok := td.getSpanKindTag(zSpan.Annotations); ok {
-		tags = append(tags, spanKindTag)
-	}
-	var traceIDHigh int64
-	if zSpan.TraceIDHigh != nil {
-		traceIDHigh = *zSpan.TraceIDHigh
-	}
-	//nolint: gosec // G115
-	traceID := model.NewTraceID(uint64(traceIDHigh), uint64(zSpan.TraceID))
-	var refs []model.SpanRef
-	if zSpan.ParentID != nil {
-		//nolint: gosec // G115
-		parentSpanID := model.NewSpanID(uint64(*zSpan.ParentID))
-		refs = model.MaybeAddParentSpanID(traceID, parentSpanID, refs)
-	}
-
-	flags := td.getFlags(zSpan)
-
-	startTime, duration := td.getStartTimeAndDuration(zSpan)
-
-	result := []*model.Span{{
-		TraceID: traceID,
-		//nolint: gosec // G115
-		SpanID:        model.NewSpanID(uint64(zSpan.ID)),
-		OperationName: zSpan.Name,
-		References:    refs,
-		Flags:         flags,
-		//nolint: gosec // G115
-		StartTime: model.EpochMicrosecondsAsTime(uint64(startTime)),
-		//nolint: gosec // G115
-		Duration: model.MicrosecondsAsDuration(uint64(duration)),
-		Tags:     tags,
-		Logs:     td.getLogs(zSpan.Annotations),
-	}}
-
-	cs := td.findAnnotation(zSpan, zipkincore.CLIENT_SEND)
-	sr := td.findAnnotation(zSpan, zipkincore.SERVER_RECV)
-	if cs != nil && sr != nil {
-		// if the span is client and server we split it into two separate spans
-		s := &model.Span{
-			TraceID: traceID,
-			//nolint: gosec // G115
-			SpanID:        model.NewSpanID(uint64(zSpan.ID)),
-			OperationName: zSpan.Name,
-			References:    refs,
-			Flags:         flags,
-		}
-		// if the first span is a client span we create server span and vice-versa.
-		if result[0].IsRPCClient() {
-			s.Tags = []model.KeyValue{model.SpanKindTag(model.SpanKindServer)}
-			//nolint: gosec // G115
-			s.StartTime = model.EpochMicrosecondsAsTime(uint64(sr.Timestamp))
-			if ss := td.findAnnotation(zSpan, zipkincore.SERVER_SEND); ss != nil {
-				//nolint: gosec // G115
-				s.Duration = model.MicrosecondsAsDuration(uint64(ss.Timestamp - sr.Timestamp))
-			}
-		} else {
-			s.Tags = []model.KeyValue{model.SpanKindTag(model.SpanKindClient)}
-			//nolint: gosec // G115
-			s.StartTime = model.EpochMicrosecondsAsTime(uint64(cs.Timestamp))
-			if cr := td.findAnnotation(zSpan, zipkincore.CLIENT_RECV); cr != nil {
-				//nolint: gosec // G115
-				s.Duration = model.MicrosecondsAsDuration(uint64(cr.Timestamp - cs.Timestamp))
-			}
-		}
-		result = append(result, s)
-	}
-	return result
-}
-
-// getFlags takes a Zipkin Span and deduces the proper flags settings
-func (toDomain) getFlags(zSpan *zipkincore.Span) model.Flags {
-	f := model.Flags(0)
-	if zSpan.Debug {
-		f.SetDebug()
-	}
-	return f
-}
-
-// Get a correct start time to use for the span if it's not set directly
-func (td toDomain) getStartTimeAndDuration(zSpan *zipkincore.Span) (timestamp, duration int64) {
-	timestamp = zSpan.GetTimestamp()
-	duration = zSpan.GetDuration()
-	if timestamp == 0 {
-		cs := td.findAnnotation(zSpan, zipkincore.CLIENT_SEND)
-		sr := td.findAnnotation(zSpan, zipkincore.SERVER_RECV)
-		if cs != nil {
-			timestamp = cs.Timestamp
-			cr := td.findAnnotation(zSpan, zipkincore.CLIENT_RECV)
-			if cr != nil && duration == 0 {
-				duration = cr.Timestamp - cs.Timestamp
-			}
-		} else if sr != nil {
-			timestamp = sr.Timestamp
-			ss := td.findAnnotation(zSpan, zipkincore.SERVER_SEND)
-			if ss != nil && duration == 0 {
-				duration = ss.Timestamp - sr.Timestamp
-			}
-		}
-	}
-	return timestamp, duration
-}
-
-// generateProcess takes a Zipkin Span and produces a model.Process.
-// An optional error may also be returned, but it is not fatal.
-func (td toDomain) generateProcess(zSpan *zipkincore.Span) (*model.Process, error) {
-	tags := td.getTags(zSpan.BinaryAnnotations, td.isProcessTag)
-	for i, tag := range tags {
-		tags[i].Key = processTagAnnotations[tag.Key]
-	}
-	serviceName, ipv4, err := td.findServiceNameAndIP(zSpan)
-	if ipv4 != 0 {
-		// If the ip process tag already exists, don't add it again
-		//nolint: gosec // G115
-		tags = append(tags, model.Int64(IPTagName, int64(uint64(ipv4))))
-	}
-	return model.NewProcess(serviceName, tags), err
-}
-
-func (td toDomain) findServiceNameAndIP(zSpan *zipkincore.Span) (string, int32, error) {
-	for _, a := range zSpan.Annotations {
-		if td.isCoreAnnotation(a) && a.Host != nil && a.Host.ServiceName != "" {
-			return a.Host.ServiceName, a.Host.Ipv4, nil
-		}
-	}
-	for _, a := range zSpan.BinaryAnnotations {
-		if a.Key == zipkincore.LOCAL_COMPONENT && a.Host != nil && a.Host.ServiceName != "" {
-			return a.Host.ServiceName, a.Host.Ipv4, nil
-		}
-	}
-	// If no core annotations exist, use the service name from any annotation
-	for _, a := range zSpan.Annotations {
-		if a.Host != nil && a.Host.ServiceName != "" {
-			return a.Host.ServiceName, a.Host.Ipv4, nil
-		}
-	}
-	// Tracer can also report a span with just binary annotation/s
-	for _, a := range zSpan.BinaryAnnotations {
-		if a.Host != nil && a.Host.ServiceName != "" {
-			return a.Host.ServiceName, a.Host.Ipv4, nil
-		}
-	}
-	err := fmt.Errorf(
-		"cannot find service name in Zipkin span [traceID=%x, spanID=%x]",
-		//nolint: gosec // G115
-		uint64(zSpan.TraceID), uint64(zSpan.ID))
-	return UnknownServiceName, 0, err
-}
-
-func (toDomain) isCoreAnnotation(annotation *zipkincore.Annotation) bool {
-	_, ok := coreAnnotations[annotation.Value]
-	return ok
-}
-
-func (toDomain) isProcessTag(binaryAnnotation *zipkincore.BinaryAnnotation) bool {
-	_, ok := processTagAnnotations[binaryAnnotation.Key]
-	return ok
-}
-
-func (td toDomain) isSpanTag(binaryAnnotation *zipkincore.BinaryAnnotation) bool {
-	return !td.isProcessTag(binaryAnnotation)
-}
-
-type tagPredicate func(*zipkincore.BinaryAnnotation) bool
-
-func (td toDomain) getTags(binAnnotations []*zipkincore.BinaryAnnotation, tagInclude tagPredicate) []model.KeyValue {
-	// this will be memory intensive due to how slices work, and it's specifically because we have to filter out
-	// some binary annotations. improvement here would be just collecting the indices in binAnnotations we want.
-	var retMe []model.KeyValue
-	for _, annotation := range binAnnotations {
-		if !tagInclude(annotation) {
-			continue
-		}
-		switch annotation.Key {
-		case zipkincore.LOCAL_COMPONENT:
-			value := string(annotation.Value)
-			tag := model.String(component, value)
-			retMe = append(retMe, tag)
-		case zipkincore.SERVER_ADDR, zipkincore.CLIENT_ADDR, zipkincore.MESSAGE_ADDR:
-			retMe = td.getPeerTags(annotation.Host, retMe)
-		default:
-			tag, err := td.transformBinaryAnnotation(annotation)
-			if err != nil {
-				encoded := base64.StdEncoding.EncodeToString(annotation.Value)
-				errMsg := fmt.Sprintf("Cannot parse Zipkin value %s: %v", encoded, err)
-				tag = model.String(annotation.Key, errMsg)
-			}
-			retMe = append(retMe, tag)
-		}
-	}
-	return retMe
-}
-
-func (toDomain) transformBinaryAnnotation(binaryAnnotation *zipkincore.BinaryAnnotation) (model.KeyValue, error) {
-	switch binaryAnnotation.AnnotationType {
-	case zipkincore.AnnotationType_BOOL:
-		vBool := bytes.Equal(binaryAnnotation.Value, trueByteSlice)
-		return model.Bool(binaryAnnotation.Key, vBool), nil
-	case zipkincore.AnnotationType_BYTES:
-		return model.Binary(binaryAnnotation.Key, binaryAnnotation.Value), nil
-	case zipkincore.AnnotationType_DOUBLE:
-		var d float64
-		if err := bytesToNumber(binaryAnnotation.Value, &d); err != nil {
-			return model.KeyValue{}, err
-		}
-		return model.Float64(binaryAnnotation.Key, d), nil
-	case zipkincore.AnnotationType_I16:
-		var i int16
-		if err := bytesToNumber(binaryAnnotation.Value, &i); err != nil {
-			return model.KeyValue{}, err
-		}
-		return model.Int64(binaryAnnotation.Key, int64(i)), nil
-	case zipkincore.AnnotationType_I32:
-		var i int32
-		if err := bytesToNumber(binaryAnnotation.Value, &i); err != nil {
-			return model.KeyValue{}, err
-		}
-		return model.Int64(binaryAnnotation.Key, int64(i)), nil
-	case zipkincore.AnnotationType_I64:
-		var i int64
-		if err := bytesToNumber(binaryAnnotation.Value, &i); err != nil {
-			return model.KeyValue{}, err
-		}
-		return model.Int64(binaryAnnotation.Key, int64(i)), nil
-	case zipkincore.AnnotationType_STRING:
-		return model.String(binaryAnnotation.Key, string(binaryAnnotation.Value)), nil
-	}
-	return model.KeyValue{}, fmt.Errorf("unknown zipkin annotation type: %d", binaryAnnotation.AnnotationType)
-}
-
-func bytesToNumber(b []byte, number any) error {
-	buf := bytes.NewReader(b)
-	return binary.Read(buf, binary.BigEndian, number)
-}
-
-func (td toDomain) getLogs(annotations []*zipkincore.Annotation) []model.Log {
-	var retMe []model.Log
-	for _, a := range annotations {
-		// If the annotation has no value, throw it out
-		if a.Value == "" {
-			continue
-		}
-		if _, ok := coreAnnotations[a.Value]; ok {
-			// skip core annotations
-			continue
-		}
-		logFields := td.getLogFields(a)
-		jLog := model.Log{
-			//nolint: gosec // G115
-			Timestamp: model.EpochMicrosecondsAsTime(uint64(a.Timestamp)),
-			Fields:    logFields,
-		}
-		retMe = append(retMe, jLog)
-	}
-	return retMe
-}
-
-func (toDomain) getLogFields(annotation *zipkincore.Annotation) []model.KeyValue {
-	var logFields map[string]string
-	// Since Zipkin format does not support kv-logging, some clients encode those Logs
-	// as annotations with JSON value. Therefore, we try JSON decoding first.
-	if err := json.Unmarshal([]byte(annotation.Value), &logFields); err == nil {
-		fields := make([]model.KeyValue, len(logFields))
-		i := 0
-		for k, v := range logFields {
-			fields[i] = model.String(k, v)
-			i++
-		}
-		return fields
-	}
-	return []model.KeyValue{model.String(DefaultLogFieldKey, annotation.Value)}
-}
-
-func (toDomain) getSpanKindTag(annotations []*zipkincore.Annotation) (model.KeyValue, bool) {
-	for _, a := range annotations {
-		if spanKind, ok := coreAnnotations[a.Value]; ok {
-			return model.SpanKindTag(model.SpanKind(spanKind)), true
-		}
-	}
-	return model.KeyValue{}, false
-}
-
-func (toDomain) getPeerTags(endpoint *zipkincore.Endpoint, tags []model.KeyValue) []model.KeyValue {
-	if endpoint == nil {
-		return tags
-	}
-	tags = append(tags, model.String(peerservice, endpoint.ServiceName))
-	if endpoint.Ipv4 != 0 {
-		//nolint: gosec // G115
-		ipv4 := int64(uint32(endpoint.Ipv4))
-		tags = append(tags, model.Int64(peerHostIPv4, ipv4))
-	}
-	if endpoint.Ipv6 != nil {
-		// Zipkin defines Ipv6 field as: "IPv6 host address packed into 16 bytes. Ex Inet6Address.getBytes()".
-		// https://github.com/openzipkin/zipkin-api/blob/master/thrift/zipkinCore.thrift#L305
-		tags = append(tags, model.Binary(peerHostIPv6, endpoint.Ipv6))
-	}
-	if endpoint.Port != 0 {
-		//nolint: gosec // G115
-		port := int64(uint16(endpoint.Port))
-		tags = append(tags, model.Int64(peerPort, port))
-	}
-	return tags
-}



Test patch:
diff --git a/cmd/collector/app/handler/zipkin_receiver_test.go b/cmd/collector/app/handler/zipkin_receiver_test.go
index fd19e5f6..e8955491 100644
--- a/cmd/collector/app/handler/zipkin_receiver_test.go
+++ b/cmd/collector/app/handler/zipkin_receiver_test.go
@@ -15,6 +15,7 @@ import (
 
 	gogojsonpb "github.com/gogo/protobuf/jsonpb"
 	gogoproto "github.com/gogo/protobuf/proto"
+	zipkinthrift "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin/zipkinthriftconverter"
 	"github.com/open-telemetry/opentelemetry-collector-contrib/receiver/zipkinreceiver"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -26,7 +27,6 @@ import (
 	"github.com/jaegertracing/jaeger/cmd/collector/app/flags"
 	"github.com/jaegertracing/jaeger/cmd/collector/app/processor"
 	"github.com/jaegertracing/jaeger/internal/testutils"
-	zipkinthrift "github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"
 	"github.com/jaegertracing/jaeger/pkg/tenancy"
 	zipkin_proto3 "github.com/jaegertracing/jaeger/proto-gen/zipkin"
 )
@@ -54,7 +54,9 @@ func TestZipkinReceiver(t *testing.T) {
 	makeThrift := func(data []byte) []byte {
 		var spans []*zipkincore.Span
 		require.NoError(t, json.Unmarshal(data, &spans))
-		return zipkinthrift.SerializeThrift(context.Background(), spans)
+		out, err := zipkinthrift.SerializeThrift(context.Background(), spans)
+		require.NoError(t, err)
+		return out
 	}
 
 	makeProto := func(data []byte) []byte {
diff --git a/internal/storage/v1/kafka/marshalling_test.go b/internal/storage/v1/kafka/marshalling_test.go
index 7ea7b90c..dd684ad4 100644
--- a/internal/storage/v1/kafka/marshalling_test.go
+++ b/internal/storage/v1/kafka/marshalling_test.go
@@ -7,11 +7,11 @@ import (
 	"context"
 	"testing"
 
+	zipkin "github.com/open-telemetry/opentelemetry-collector-contrib/pkg/translator/zipkin/zipkinthriftconverter"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 
 	"github.com/jaegertracing/jaeger-idl/thrift-gen/zipkincore"
-	"github.com/jaegertracing/jaeger/model/converter/thrift/zipkin"
 )
 
 func TestProtobufMarshallerAndUnmarshaller(t *testing.T) {
@@ -36,7 +36,7 @@ func testMarshallerAndUnmarshaller(t *testing.T, marshaller Marshaller, unmarsha
 
 func TestZipkinThriftUnmarshaller(t *testing.T) {
 	operationName := "foo"
-	bytes := zipkin.SerializeThrift(context.Background(), []*zipkincore.Span{
+	bytes, err := zipkin.SerializeThrift(context.Background(), []*zipkincore.Span{
 		{
 			ID:   12345,
 			Name: operationName,
@@ -45,6 +45,7 @@ func TestZipkinThriftUnmarshaller(t *testing.T) {
 			},
 		},
 	})
+	require.NoError(t, err)
 	unmarshaller := NewZipkinThriftUnmarshaller()
 	resultSpan, err := unmarshaller.Unmarshal(bytes)
 
@@ -53,14 +54,15 @@ func TestZipkinThriftUnmarshaller(t *testing.T) {
 }
 
 func TestZipkinThriftUnmarshallerErrorNoService(t *testing.T) {
-	bytes := zipkin.SerializeThrift(context.Background(), []*zipkincore.Span{
+	bytes, err := zipkin.SerializeThrift(context.Background(), []*zipkincore.Span{
 		{
 			ID:   12345,
 			Name: "foo",
 		},
 	})
+	require.NoError(t, err)
 	unmarshaller := NewZipkinThriftUnmarshaller()
-	_, err := unmarshaller.Unmarshal(bytes)
+	_, err = unmarshaller.Unmarshal(bytes)
 	require.Error(t, err)
 }
 
diff --git a/model/converter/thrift/zipkin/deserialize_test.go b/model/converter/thrift/zipkin/deserialize_test.go
deleted file mode 100644
index 2e09d01f..00000000
--- a/model/converter/thrift/zipkin/deserialize_test.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2018 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"context"
-	"testing"
-
-	"github.com/stretchr/testify/require"
-
-	"github.com/jaegertracing/jaeger-idl/thrift-gen/zipkincore"
-)
-
-func TestDeserializeWithBadListStart(t *testing.T) {
-	ctx := context.Background()
-	spanBytes := SerializeThrift(ctx, []*zipkincore.Span{{}})
-	_, err := DeserializeThrift(ctx, append([]byte{0, 255, 255}, spanBytes...))
-	require.Error(t, err)
-}
-
-func TestDeserializeWithCorruptedList(t *testing.T) {
-	ctx := context.Background()
-	spanBytes := SerializeThrift(ctx, []*zipkincore.Span{{}})
-	spanBytes[2] = 255
-	_, err := DeserializeThrift(ctx, spanBytes)
-	require.Error(t, err)
-}
-
-func TestDeserialize(t *testing.T) {
-	ctx := context.Background()
-	spanBytes := SerializeThrift(ctx, []*zipkincore.Span{{}})
-	_, err := DeserializeThrift(ctx, spanBytes)
-	require.NoError(t, err)
-}
diff --git a/model/converter/thrift/zipkin/package_test.go b/model/converter/thrift/zipkin/package_test.go
deleted file mode 100644
index 84896032..00000000
--- a/model/converter/thrift/zipkin/package_test.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright (c) 2023 The Jaeger Authors.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"testing"
-
-	"github.com/jaegertracing/jaeger/internal/testutils"
-)
-
-func TestMain(m *testing.M) {
-	testutils.VerifyGoLeaks(m)
-}
diff --git a/model/converter/thrift/zipkin/process_hashtable_test.go b/model/converter/thrift/zipkin/process_hashtable_test.go
deleted file mode 100644
index c9af03e2..00000000
--- a/model/converter/thrift/zipkin/process_hashtable_test.go
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-
-	"github.com/jaegertracing/jaeger-idl/model/v1"
-)
-
-func TestProcessHashtable(t *testing.T) {
-	p1 := model.NewProcess("s1", []model.KeyValue{
-		model.String("host", "google.com"),
-	})
-	p1dup := model.NewProcess("s1", []model.KeyValue{
-		model.String("host", "google.com"),
-	})
-	p2 := model.NewProcess("s2", []model.KeyValue{
-		model.String("host", "facebook.com"),
-	})
-	ht := newProcessHashtable()
-	assert.Equal(t, p1, ht.add(p1))
-	assert.Equal(t, p2, ht.add(p2))
-	assert.Equal(t, p1, ht.add(p1))
-	assert.Equal(t, p2, ht.add(p2))
-	assert.Equal(t, p1, ht.add(p1dup))
-}
-
-func TestProcessHashtableCollision(t *testing.T) {
-	ht := newProcessHashtable()
-	// hash all processes to the same number
-	ht.extHash = func(*model.Process) uint64 {
-		return 42
-	}
-
-	p1 := model.NewProcess("s1", []model.KeyValue{
-		model.String("host", "google.com"),
-	})
-	p2 := model.NewProcess("s2", []model.KeyValue{
-		model.String("host", "facebook.com"),
-	})
-	assert.Equal(t, p1, ht.add(p1))
-	assert.Equal(t, p2, ht.add(p2))
-	assert.Equal(t, p1, ht.add(p1))
-	assert.Equal(t, p2, ht.add(p2))
-}
diff --git a/model/converter/thrift/zipkin/to_domain_test.go b/model/converter/thrift/zipkin/to_domain_test.go
deleted file mode 100644
index 3189fc61..00000000
--- a/model/converter/thrift/zipkin/to_domain_test.go
+++ /dev/null
@@ -1,206 +0,0 @@
-// Copyright (c) 2019 The Jaeger Authors.
-// Copyright (c) 2017 Uber Technologies, Inc.
-// SPDX-License-Identifier: Apache-2.0
-
-package zipkin
-
-import (
-	"bytes"
-	"encoding/base64"
-	"encoding/binary"
-	"encoding/json"
-	"fmt"
-	"math"
-	"os"
-	"testing"
-	"time"
-
-	"github.com/gogo/protobuf/jsonpb"
-	"github.com/gogo/protobuf/proto"
-	"github.com/kr/pretty"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/jaegertracing/jaeger-idl/model/v1"
-	z "github.com/jaegertracing/jaeger-idl/thrift-gen/zipkincore"
-)
-
-const NumberOfFixtures = 3
-
-func TestToDomain(t *testing.T) {
-	for i := 1; i <= NumberOfFixtures; i++ {
-		in := fmt.Sprintf("fixtures/zipkin_%02d.json", i)
-		out := fmt.Sprintf("fixtures/domain_%02d.json", i)
-		zSpans := loadZipkinSpans(t, in)
-		expectedTrace := loadJaegerTrace(t, out)
-		expectedTrace.NormalizeTimestamps()
-		name := in + " -> " + out + " : " + zSpans[0].Name
-		t.Run(name, func(t *testing.T) {
-			trace, err := ToDomain(zSpans)
-			require.NoError(t, err)
-			trace.NormalizeTimestamps()
-			if !assert.Equal(t, expectedTrace, trace) {
-				for _, err := range pretty.Diff(expectedTrace, trace) {
-					t.Log(err)
-				}
-				out, err := json.Marshal(trace)
-				require.NoError(t, err)
-				t.Logf("Actual trace: %s", string(out))
-			}
-		})
-		if i == 1 {
-			t.Run("ToDomainSpans", func(t *testing.T) {
-				zSpan := zSpans[0]
-				jSpans, err := ToDomainSpan(zSpan)
-				require.NoError(t, err)
-				for _, jSpan := range jSpans {
-					jSpan.NormalizeTimestamps()
-					assert.Equal(t, expectedTrace.Spans[0], jSpan)
-				}
-			})
-		}
-	}
-}
-
-func TestToDomainNoServiceNameError(t *testing.T) {
-	zSpans := getZipkinSpans(t, `[{ "trace_id": -1, "id": 31 }]`)
-	trc, err := ToDomain(zSpans)
-	require.EqualError(t, err, "cannot find service name in Zipkin span [traceID=ffffffffffffffff, spanID=1f]")
-	assert.Len(t, trc.Spans, 1)
-	assert.Equal(t, "unknown-service-name", trc.Spans[0].Process.ServiceName)
-}
-
-func TestToDomainServiceNameInBinAnnotation(t *testing.T) {
-	zSpans := getZipkinSpans(t, `[{ "trace_id": -1, "id": 31,
-	"binary_annotations": [{"key": "foo", "host": {"service_name": "bar", "ipv4": 23456}}] }]`)
-	trc, err := ToDomain(zSpans)
-	require.NoError(t, err)
-	assert.Len(t, trc.Spans, 1)
-	assert.Equal(t, "bar", trc.Spans[0].Process.ServiceName)
-}
-
-func TestToDomainWithDurationFromServerAnnotations(t *testing.T) {
-	zSpans := getZipkinSpans(t, `[{ "trace_id": -1, "id": 31, "annotations": [
-	{"value": "sr", "timestamp": 1, "host": {"service_name": "bar", "ipv4": 23456}},
-	{"value": "ss", "timestamp": 10, "host": {"service_name": "bar", "ipv4": 23456}}
-	]}]`)
-	trc, err := ToDomain(zSpans)
-	require.NoError(t, err)
-	assert.Equal(t, 1000, int(trc.Spans[0].StartTime.Nanosecond()))
-	assert.Equal(t, 9000, int(trc.Spans[0].Duration))
-}
-
-func TestToDomainWithDurationFromClientAnnotations(t *testing.T) {
-	zSpans := getZipkinSpans(t, `[{ "trace_id": -1, "id": 31, "annotations": [
-	{"value": "cs", "timestamp": 1, "host": {"service_name": "bar", "ipv4": 23456}},
-	{"value": "cr", "timestamp": 10, "host": {"service_name": "bar", "ipv4": 23456}}
-	]}]`)
-	trc, err := ToDomain(zSpans)
-	require.NoError(t, err)
-	assert.Equal(t, 1000, int(trc.Spans[0].StartTime.Nanosecond()))
-	assert.Equal(t, 9000, int(trc.Spans[0].Duration))
-}
-
-func TestToDomainMultipleSpanKinds(t *testing.T) {
-	tests := []struct {
-		json         string
-		tagFirstKey  string
-		tagSecondKey string
-		tagFirstVal  model.SpanKind
-		tagSecondVal model.SpanKind
-	}{
-		{
-			json: `[{ "trace_id": -1, "id": 31, "annotations": [
-		{"value": "cs", "host": {"service_name": "bar", "ipv4": 23456}},
-		{"value": "sr", "timestamp": 1, "host": {"service_name": "bar", "ipv4": 23456}},
-		{"value": "ss", "timestamp": 2, "host": {"service_name": "bar", "ipv4": 23456}}
-		]}]`,
-			tagFirstKey:  model.SpanKindKey,
-			tagSecondKey: model.SpanKindKey,
-			tagFirstVal:  model.SpanKindClient,
-			tagSecondVal: model.SpanKindServer,
-		},
-		{
-			json: `[{ "trace_id": -1, "id": 31, "annotations": [
-		{"value": "sr", "host": {"service_name": "bar", "ipv4": 23456}},
-		{"value": "cs", "timestamp": 1, "host": {"service_name": "bar", "ipv4": 23456}},
-		{"value": "cr", "timestamp": 2, "host": {"service_name": "bar", "ipv4": 23456}}
-		]}]`,
-			tagFirstKey:  model.SpanKindKey,
-			tagSecondKey: model.SpanKindKey,
-			tagFirstVal:  model.SpanKindServer,
-			tagSecondVal: model.SpanKindClient,
-		},
-	}
-
-	for _, test := range tests {
-		trc, err := ToDomain(getZipkinSpans(t, test.json))
-		require.NoError(t, err)
-
-		assert.Len(t, trc.Spans, 2)
-		assert.Len(t, trc.Spans[0].Tags, 1)
-		assert.Equal(t, test.tagFirstKey, trc.Spans[0].Tags[0].Key)
-		assert.EqualValues(t, test.tagFirstVal, trc.Spans[0].Tags[0].VStr)
-
-		assert.Len(t, trc.Spans[1].Tags, 1)
-		assert.Equal(t, test.tagSecondKey, trc.Spans[1].Tags[0].Key)
-		assert.Equal(t, time.Duration(1000), trc.Spans[1].Duration)
-		assert.EqualValues(t, test.tagSecondVal, trc.Spans[1].Tags[0].VStr)
-	}
-}
-
-func TestInvalidAnnotationTypeError(t *testing.T) {
-	_, err := toDomain{}.transformBinaryAnnotation(&z.BinaryAnnotation{
-		AnnotationType: -1,
-	})
-	require.EqualError(t, err, "unknown zipkin annotation type: -1")
-}
-
-// TestZipkinEncoding is just for reference to explain the base64 strings
-// used in zipkin_03.json and jaeger_03.json fixtures
-func TestValidateBase64Values(t *testing.T) {
-	numberToBase64 := func(num any) string {
-		buf := &bytes.Buffer{}
-		binary.Write(buf, binary.BigEndian, num)
-		encoded := base64.StdEncoding.EncodeToString(buf.Bytes())
-		return encoded
-	}
-
-	assert.Equal(t, "MDk=", numberToBase64(int16(12345)))
-	assert.Equal(t, "AAAwOQ==", numberToBase64(int32(12345)))
-	assert.Equal(t, "AAAAAAAAMDk=", numberToBase64(int64(12345)))
-	assert.Equal(t, "QMgcgAAAAAA=", numberToBase64(int64(math.Float64bits(12345))))
-	assert.Equal(t, int64(4668012349850910720), int64(math.Float64bits(12345)), "sanity check")
-}
-
-func loadZipkinSpans(t *testing.T, file string) []*z.Span {
-	var zSpans []*z.Span
-	loadJSON(t, file, &zSpans)
-	return zSpans
-}
-
-func loadJaegerTrace(t *testing.T, file string) *model.Trace {
-	var trc model.Trace
-	loadJSONPB(t, file, &trc)
-	return &trc
-}
-
-func loadJSONPB(t *testing.T, fileName string, obj proto.Message) {
-	jsonFile, err := os.Open(fileName)
-	require.NoError(t, err, "Failed to open json fixture file %s", fileName)
-	require.NoError(t, jsonpb.Unmarshal(jsonFile, obj), fileName)
-}
-
-func getZipkinSpans(t *testing.T, s string) []*z.Span {
-	var zSpans []*z.Span
-	require.NoError(t, json.Unmarshal([]byte(s), &zSpans))
-	return zSpans
-}
-
-func loadJSON(t *testing.T, fileName string, i any) {
-	jsonFile, err := os.Open(fileName)
-	require.NoError(t, err, "Failed to load json fixture file %s", fileName)
-	jsonParser := json.NewDecoder(jsonFile)
-	err = jsonParser.Decode(i)
-	require.NoError(t, err, "Failed to parse json fixture file %s", fileName)
-}