[test] Upgrade span_tags_trace.json from v1 model to ptrace.Traces (#8044)

## Which problem is this PR solving?
- Fixes a part of: #7050 

## Description of the changes
- This init the environment to swap fixtures with v2. One of the
fixtures is also swapped here.

## How was this change tested?
- Unit and Integration tests

## Checklist
- [x] I have read
https://github.com/jaegertracing/jaeger/blob/main/CONTRIBUTING_GUIDELINES.md
- [x] I have signed all commits
- [x] I have added unit tests for the new functionality
- [x] I have run lint and test steps successfully: `make lint test`

## AI Usage in this PR (choose one)
See [AI Usage
Policy](https://github.com/jaegertracing/jaeger/blob/main/CONTRIBUTING_GUIDELINES.md#ai-usage-policy).
- [x] **None**: No AI tools were used in creating this PR
- [ ] **Light**: AI provided minor assistance (formatting, simple
suggestions)
- [ ] **Moderate**: AI helped with code generation or debugging specific
parts
- [ ] **Heavy**: AI generated most or all of the code changes

---------

Signed-off-by: Manik Mehta <mehtamanik96@gmail.com>

Author: Manik2708

cmd/trace-converter/.gitignore

@@ -0,0 +1 @@
+trace-converter-*-*

cmd/trace-converter/main.go

@@ -0,0 +1,142 @@
+// Copyright (c) 2026 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/spf13/cobra"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+
+	"github.com/jaegertracing/jaeger-idl/model/v1"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/v1adapter"
+)
+
+const (
+	inFile     = "in-file"
+	outFile    = "out-file"
+	rootPath   = "root-path"
+	fileFormat = "%s.json"
+)
+
+func main() {
+	if err := newRootCmd().Execute(); err != nil {
+		os.Exit(1)
+	}
+}
+
+func newRootCmd() *cobra.Command {
+	rootCmd := &cobra.Command{
+		Use:   "jaeger-trace-converter",
+		Short: "Jaeger trace-converter converts v1 trace fixtures to OTLP trace fixtures",
+		Long:  "Jaeger trace-converter converts v1 trace fixtures to OTLP trace fixtures",
+	}
+	flags := rootCmd.Flags()
+	flags.String(inFile, "", "The name of file to read from (where v1 fixtures are located without .json)")
+	flags.String(outFile, "", "The name of file where otlp fixtures are needed to be written (without .json). If given empty, fixtures will be written to input file")
+	flags.String(rootPath, "", "The root path to use to convert the traces to OTLP fixtures")
+	if err := rootCmd.MarkFlagRequired(inFile); err != nil {
+		panic(err)
+	}
+	if err := rootCmd.MarkFlagRequired(rootPath); err != nil {
+		panic(err)
+	}
+	rootCmd.RunE = func(cmd *cobra.Command, _ []string) error {
+		in, err := cmd.Flags().GetString(inFile)
+		if err != nil {
+			return err
+		}
+		out, err := cmd.Flags().GetString(outFile)
+		if err != nil {
+			return err
+		}
+		root, err := cmd.Flags().GetString(rootPath)
+		if err != nil {
+			return err
+		}
+		if out == "" {
+			out = in
+		}
+		return translateFixtureToOTLPTrace(root, in, out)
+	}
+	return rootCmd
+}
+
+func translateFixtureToOTLPTrace(root, in, out string) error {
+	inPath := filepath.Join(root, fmt.Sprintf(fileFormat, in))
+	outPath := filepath.Join(root, fmt.Sprintf(fileFormat, out))
+	inStr, err := os.ReadFile(inPath)
+	if err != nil {
+		return err
+	}
+	var traceV1 model.Trace
+	if err := jsonpb.Unmarshal(bytes.NewReader(inStr), &traceV1); err != nil {
+		return err
+	}
+	trace := v1adapter.V1TraceToOtelTrace(&traceV1)
+	expected := modelTraceFromOtelTrace(trace)
+	if err := validateTraces(expected, &traceV1); err != nil {
+		return err
+	}
+	marshaller := ptrace.JSONMarshaler{}
+	outBytes, err := marshaller.MarshalTraces(trace)
+	if err != nil {
+		return err
+	}
+	var buf bytes.Buffer
+	if err := json.Indent(&buf, outBytes, "", "  "); err != nil {
+		return err
+	}
+	return os.WriteFile(outPath, buf.Bytes(), 0o600)
+}
+
+// modelTraceFromOtelTrace extracts spans from otel traces
+func modelTraceFromOtelTrace(otelTrace ptrace.Traces) *model.Trace {
+	var spans []*model.Span
+	batches := v1adapter.V1BatchesFromTraces(otelTrace)
+	for _, batch := range batches {
+		for _, span := range batch.Spans {
+			if span.Process == nil {
+				proc := *batch.Process // shallow clone
+				span.Process = &proc
+			}
+			spans = append(spans, span)
+
+			if span.Process.Tags == nil {
+				span.Process.Tags = []model.KeyValue{}
+			}
+
+			if span.References == nil {
+				span.References = []model.SpanRef{}
+			}
+			if span.Tags == nil {
+				span.Tags = []model.KeyValue{}
+			}
+			if span.Logs == nil {
+				span.Logs = []model.Log{}
+			}
+		}
+	}
+	return &model.Trace{Spans: spans}
+}
+
+func validateTraces(expected, actual *model.Trace) error {
+	expectedBytes, err := json.Marshal(expected)
+	if err != nil {
+		return err
+	}
+	actualBytes, err := json.Marshal(actual)
+	if err != nil {
+		return err
+	}
+	if !bytes.Equal(expectedBytes, actualBytes) {
+		return fmt.Errorf("traces are not equal\n actual: %s\n expected: %s", string(actualBytes), string(expectedBytes))
+	}
+	return nil
+}

cmd/trace-converter/trace-converter_test.go

@@ -0,0 +1,65 @@
+// Copyright (c) 2026 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/gogo/protobuf/jsonpb"
+	"github.com/stretchr/testify/require"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+
+	"github.com/jaegertracing/jaeger-idl/model/v1"
+	"github.com/jaegertracing/jaeger/internal/storage/integration"
+	"github.com/jaegertracing/jaeger/internal/storage/v2/v1adapter"
+	"github.com/jaegertracing/jaeger/internal/testutils"
+)
+
+func TestMain(m *testing.M) {
+	testutils.VerifyGoLeaks(m)
+}
+
+func Test_translateFixtureToOTLPTrace(t *testing.T) {
+	dir := t.TempDir()
+	tmpInFile := "v1-trace"
+	tmpInPath := filepath.Join(dir, fmt.Sprintf(fileFormat, tmpInFile))
+	v1Trace := model.Trace{Spans: []*model.Span{
+		{
+			OperationName: "jaeger",
+			References:    []model.SpanRef{},
+			Process: &model.Process{
+				Tags:        model.KeyValues{},
+				ServiceName: "jaeger-service",
+			},
+			Tags:      model.KeyValues{},
+			StartTime: time.Now(),
+			Logs:      []model.Log{},
+		},
+	}}
+	var buf bytes.Buffer
+	marshaler := jsonpb.Marshaler{}
+	require.NoError(t, marshaler.Marshal(&buf, &v1Trace))
+	require.NoError(t, os.WriteFile(tmpInPath, buf.Bytes(), 0o600))
+	tmpOutFile := "v2-trace"
+	tmpOutPath := filepath.Join(dir, fmt.Sprintf(fileFormat, tmpOutFile))
+	rootCmd := newRootCmd()
+	rootCmd.SetArgs([]string{
+		"--in-file", tmpInFile,
+		"--out-file", tmpOutFile,
+		"--root-path", dir,
+	})
+	require.NoError(t, rootCmd.Execute())
+	outBytes, err := os.ReadFile(tmpOutPath)
+	require.NoError(t, err)
+	unmarshaller := ptrace.JSONUnmarshaler{}
+	actual, err := unmarshaller.UnmarshalTraces(outBytes)
+	require.NoError(t, err)
+	expected := v1adapter.V1TraceToOtelTrace(&v1Trace)
+	integration.CompareTraces(t, expected, actual)
+}

internal/storage/integration/dates.go

@@ -0,0 +1,62 @@
+// Copyright (c) 2026 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package integration
+
+import (
+	"time"
+
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+
+	"github.com/jaegertracing/jaeger/internal/jptrace"
+)
+
+// dateOffsetNormalizer normalizes timestamps by replacing their date
+// (year, month, day) with a fixed date computed using a day offset
+// from the current UTC date, while preserving the original time.
+// This is required in integration tests because the fixtures have
+// hardcoded start time and other timestamps and we need to make them
+// recent to fetch from the reader. Timestamps whose original UTC date
+// is 2017-01-25 use a -2 day offset; all other timestamps use a -1 day
+// offset. These offsets are selected to keep the upgrade from v1 to v2 consistent.
+type dateOffsetNormalizer struct {
+	tm time.Time
+}
+
+func newDateOffsetNormalizer(tm time.Time) dateOffsetNormalizer {
+	return dateOffsetNormalizer{tm: tm}
+}
+
+func (d dateOffsetNormalizer) normalizeTrace(td ptrace.Traces) {
+	for _, span := range jptrace.SpanIter(td) {
+		span.SetStartTimestamp(d.normalizeTime(span.StartTimestamp()))
+		span.SetEndTimestamp(d.normalizeTime(span.EndTimestamp()))
+		for _, event := range span.Events().All() {
+			event.SetTimestamp(d.normalizeTime(event.Timestamp()))
+		}
+	}
+}
+
+func (d dateOffsetNormalizer) normalizeTime(t pcommon.Timestamp) pcommon.Timestamp {
+	tm := t.AsTime().UTC()
+	offset := -1
+	// Apply a -2 day offset for any timestamp whose UTC date is 2017-01-25.
+	// All other timestamps use the default -1 day offset to preserve existing behavior.
+	yearOrig, monthOrig, dayOrig := tm.Date()
+	if yearOrig == 2017 && monthOrig == time.January && dayOrig == 25 {
+		offset = -2
+	}
+	year, month, day := d.tm.UTC().AddDate(0, 0, offset).Date()
+	newTm := time.Date(
+		year,
+		month,
+		day,
+		tm.Hour(),
+		tm.Minute(),
+		tm.Second(),
+		tm.Nanosecond(),
+		tm.Location(),
+	)
+	return pcommon.NewTimestampFromTime(newTm)
+}

internal/storage/integration/dates_test.go

@@ -0,0 +1,64 @@
+// Copyright (c) 2026 The Jaeger Authors.
+// SPDX-License-Identifier: Apache-2.0
+
+package integration
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+	"go.opentelemetry.io/collector/pdata/pcommon"
+	"go.opentelemetry.io/collector/pdata/ptrace"
+)
+
+func Test_dateOffsetNormalizer(t *testing.T) {
+	origTime := time.Date(
+		2024, time.January, 10,
+		14, 30, 45, 123456789,
+		time.UTC,
+	)
+	origStartTime := time.Date(
+		2017, time.January, 25,
+		23, 56, 31, 639875000,
+		time.UTC,
+	)
+	origTs := pcommon.NewTimestampFromTime(origTime)
+	origStartTs := pcommon.NewTimestampFromTime(origStartTime)
+	twoDaysAgo := -2
+	oneDayAgo := -1
+	now := time.Now()
+	expectedTwoDaysAgo := now.UTC().AddDate(0, 0, twoDaysAgo)
+	expectedOneDayAgo := now.UTC().AddDate(0, 0, oneDayAgo)
+	normalizer := newDateOffsetNormalizer(now)
+	td := ptrace.NewTraces()
+	span := td.ResourceSpans().AppendEmpty().ScopeSpans().AppendEmpty().Spans().AppendEmpty()
+	span.SetStartTimestamp(origStartTs)
+	span.SetEndTimestamp(origTs)
+	event := span.Events().AppendEmpty()
+	event.SetTimestamp(origTs)
+	normalizer.normalizeTrace(td)
+	expectedTwoDaysAgoTime := time.Date(
+		expectedTwoDaysAgo.Year(),
+		expectedTwoDaysAgo.Month(),
+		expectedTwoDaysAgo.Day(),
+		origStartTime.Hour(),
+		origStartTime.Minute(),
+		origStartTime.Second(),
+		origStartTime.Nanosecond(),
+		time.UTC,
+	)
+	expectedOneDayAgoTime := time.Date(
+		expectedOneDayAgo.Year(),
+		expectedOneDayAgo.Month(),
+		expectedOneDayAgo.Day(),
+		origTime.Hour(),
+		origTime.Minute(),
+		origTime.Second(),
+		origTime.Nanosecond(),
+		time.UTC,
+	)
+	assert.Equal(t, expectedTwoDaysAgoTime, span.StartTimestamp().AsTime())
+	assert.Equal(t, expectedOneDayAgoTime, span.EndTimestamp().AsTime())
+	assert.Equal(t, expectedOneDayAgoTime, event.Timestamp().AsTime())
+}