Move more old internal structs to old files, and rename funcs with Old (#1662)

Signed-off-by: Bogdan Drutu <bogdandrutu@gmail.com>

consumer/pdatautil/pdatautil.go

@@ -48,10 +48,10 @@ func MetricsFromMetricsData(ocmds []consumerdata.MetricsData) pdata.Metrics {
 	return pdata.Metrics{InternalOpaque: ocmds}
 }
 
-// MetricsToInternalMetrics returns the `data.MetricData` representation of the `pdata.Metrics`.
+// MetricsToOldInternalMetrics returns the `data.MetricData` representation of the `pdata.Metrics`.
 //
 // This is a temporary function that will be removed when the new internal pdata.Metrics will be finalized.
-func MetricsToInternalMetrics(md pdata.Metrics) dataold.MetricData {
+func MetricsToOldInternalMetrics(md pdata.Metrics) dataold.MetricData {
 	if ims, ok := md.InternalOpaque.(dataold.MetricData); ok {
 		return ims
 	}
@@ -64,7 +64,7 @@ func MetricsToInternalMetrics(md pdata.Metrics) dataold.MetricData {
 // MetricsFromMetricsData returns the `pdata.Metrics` representation of the `data.MetricData`.
 //
 // This is a temporary function that will be removed when the new internal pdata.Metrics will be finalized.
-func MetricsFromInternalMetrics(md dataold.MetricData) pdata.Metrics {
+func MetricsFromOldInternalMetrics(md dataold.MetricData) pdata.Metrics {
 	return pdata.Metrics{InternalOpaque: md}
 }
 

exporter/exporterhelper/metricshelper_test.go

@@ -47,7 +47,7 @@ var (
 )
 
 func TestMetricsRequest(t *testing.T) {
-	mr := newMetricsRequest(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataEmpty()), nil)
+	mr := newMetricsRequest(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataEmpty()), nil)
 
 	partialErr := consumererror.PartialTracesError(errors.New("some error"), testdata.GenerateTraceDataOneSpan())
 	assert.Same(t, mr, mr.onPartialError(partialErr.(consumererror.PartialError)))
@@ -72,7 +72,7 @@ func TestMetricsExporter_Default(t *testing.T) {
 	assert.NotNil(t, me)
 	assert.NoError(t, err)
 
-	assert.Nil(t, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	assert.Nil(t, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 	assert.Nil(t, me.Shutdown(context.Background()))
 }
 
@@ -82,7 +82,7 @@ func TestMetricsExporter_Default_ReturnError(t *testing.T) {
 	me, err := NewMetricsExporter(fakeMetricsExporterConfig, newPushMetricsData(0, want))
 	require.Nil(t, err)
 	require.NotNil(t, me)
-	require.Equal(t, want, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	require.Equal(t, want, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 }
 
 func TestMetricsExporter_WithRecordMetrics(t *testing.T) {
@@ -169,7 +169,7 @@ func checkRecordedMetricsForMetricsExporter(t *testing.T, me component.MetricsEx
 	md := testdataold.GenerateMetricDataTwoMetrics()
 	const numBatches = 7
 	for i := 0; i < numBatches; i++ {
-		require.Equal(t, wantError, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+		require.Equal(t, wantError, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 	}
 
 	// TODO: When the new metrics correctly count partial dropped fix this.
@@ -186,7 +186,7 @@ func generateMetricsTraffic(t *testing.T, me component.MetricsExporter, numReque
 	ctx, span := trace.StartSpan(context.Background(), fakeMetricsParentSpanName, trace.WithSampler(trace.AlwaysSample()))
 	defer span.End()
 	for i := 0; i < numRequests; i++ {
-		require.Equal(t, wantError, me.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+		require.Equal(t, wantError, me.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 	}
 }
 

exporter/exportertest/nop_exporter_test.go

@@ -34,7 +34,7 @@ func TestNopTraceExporter(t *testing.T) {
 func TestNopMetricsExporter(t *testing.T) {
 	nme := NewNopMetricsExporter()
 	require.NoError(t, nme.Start(context.Background(), nil))
-	require.NoError(t, nme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(dataold.NewMetricData())))
+	require.NoError(t, nme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(dataold.NewMetricData())))
 	require.NoError(t, nme.Shutdown(context.Background()))
 }
 

exporter/exportertest/sink_exporter.go

@@ -123,7 +123,7 @@ func (sme *SinkMetricsExporter) ConsumeMetrics(_ context.Context, md pdata.Metri
 	}
 
 	sme.metrics = append(sme.metrics, md)
-	sme.metricsCount += pdatautil.MetricsToInternalMetrics(md).MetricCount()
+	sme.metricsCount += pdatautil.MetricsToOldInternalMetrics(md).MetricCount()
 
 	return nil
 }

exporter/exportertest/sink_exporter_test.go

@@ -62,8 +62,8 @@ func TestSinkMetricsExporter(t *testing.T) {
 	md := testdataold.GenerateMetricDataOneMetric()
 	want := make([]pdata.Metrics, 0, 7)
 	for i := 0; i < 7; i++ {
-		require.NoError(t, sink.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+		require.NoError(t, sink.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
-		want = append(want, pdatautil.MetricsFromInternalMetrics(md))
+		want = append(want, pdatautil.MetricsFromOldInternalMetrics(md))
 	}
 	assert.Equal(t, want, sink.AllMetrics())
 	assert.Equal(t, len(want), sink.MetricsCount())
@@ -78,7 +78,7 @@ func TestSinkMetricsExporter_Error(t *testing.T) {
 	require.NoError(t, sink.Start(context.Background(), componenttest.NewNopHost()))
 	sink.SetConsumeMetricsError(errors.New("my error"))
 	md := testdataold.GenerateMetricDataOneMetric()
-	require.Error(t, sink.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	require.Error(t, sink.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 	assert.Len(t, sink.AllMetrics(), 0)
 	assert.Equal(t, 0, sink.MetricsCount())
 	require.NoError(t, sink.Shutdown(context.Background()))

exporter/fileexporter/file_exporter.go

@@ -50,7 +50,7 @@ func (e *fileExporter) ConsumeTraces(_ context.Context, td pdata.Traces) error {
 
 func (e *fileExporter) ConsumeMetrics(_ context.Context, md pdata.Metrics) error {
 	request := otlpmetrics.ExportMetricsServiceRequest{
-		ResourceMetrics: dataold.MetricDataToOtlp(pdatautil.MetricsToInternalMetrics(md)),
+		ResourceMetrics: dataold.MetricDataToOtlp(pdatautil.MetricsToOldInternalMetrics(md)),
 	}
 	return exportMessageAsLine(e, &request)
 }

exporter/fileexporter/file_exporter_test.go

@@ -58,7 +58,7 @@ func TestFileMetricsExporterNoErrors(t *testing.T) {
 	lme := &fileExporter{file: mf}
 	require.NotNil(t, lme)
 
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
 	assert.NoError(t, lme.ConsumeMetrics(context.Background(), md))
 	assert.NoError(t, lme.Shutdown(context.Background()))
 
@@ -66,7 +66,7 @@ func TestFileMetricsExporterNoErrors(t *testing.T) {
 	var j collectormetrics.ExportMetricsServiceRequest
 	assert.NoError(t, unmarshaler.Unmarshal(mf, &j))
 
-	assert.EqualValues(t, dataold.MetricDataToOtlp(pdatautil.MetricsToInternalMetrics(md)), j.ResourceMetrics)
+	assert.EqualValues(t, dataold.MetricDataToOtlp(pdatautil.MetricsToOldInternalMetrics(md)), j.ResourceMetrics)
 }
 
 func TestFileLogsExporterNoErrors(t *testing.T) {

exporter/loggingexporter/logging_exporter.go

@@ -364,7 +364,7 @@ func (s *loggingExporter) pushMetricsData(
 	_ context.Context,
 	md pdata.Metrics,
 ) (int, error) {
-	imd := pdatautil.MetricsToInternalMetrics(md)
+	imd := pdatautil.MetricsToOldInternalMetrics(md)
 	s.logger.Info("MetricsExporter", zap.Int("#metrics", imd.MetricCount()))
 
 	if !s.debug {

exporter/loggingexporter/logging_exporter_test.go

@@ -46,15 +46,15 @@ func TestLoggingMetricsExporterNoErrors(t *testing.T) {
 	require.NotNil(t, lme)
 	assert.NoError(t, err)
 
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataEmpty())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataEmpty())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataOneEmptyOneNilResourceMetrics())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataOneEmptyOneNilResourceMetrics())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataOneEmptyOneNilInstrumentationLibrary())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataOneEmptyOneNilInstrumentationLibrary())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataOneMetricOneNil())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataOneMetricOneNil())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataWithCountersHistogramAndSummary())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataWithCountersHistogramAndSummary())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataAllTypesNilDataPoint())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataAllTypesNilDataPoint())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataAllTypesEmptyDataPoint())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataAllTypesEmptyDataPoint())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataNilMetricDescriptor())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataNilMetricDescriptor())))
-	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataMetricTypeInvalid())))
+	assert.NoError(t, lme.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataMetricTypeInvalid())))
 
 	assert.NoError(t, lme.Shutdown(context.Background()))
 }

exporter/opencensusexporter/opencensus_test.go

@@ -167,18 +167,18 @@ func TestSendMetrics(t *testing.T) {
 	})
 
 	md := testdataold.GenerateMetricDataOneMetric()
-	assert.NoError(t, exp.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, exp.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 	testutil.WaitFor(t, func() bool {
 		return len(sink.AllMetrics()) == 1
 	})
 	metrics := sink.AllMetrics()
 	require.Len(t, metrics, 1)
-	assert.Equal(t, md, pdatautil.MetricsToInternalMetrics(metrics[0]))
+	assert.Equal(t, md, pdatautil.MetricsToOldInternalMetrics(metrics[0]))
 
 	// Sending data no node.
 	sink.Reset()
 	pdata.NewResource().CopyTo(md.ResourceMetrics().At(0).Resource())
-	assert.NoError(t, exp.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, exp.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 	testutil.WaitFor(t, func() bool {
 		return len(sink.AllMetrics()) == 1
 	})
@@ -186,7 +186,7 @@ func TestSendMetrics(t *testing.T) {
 	require.Len(t, metrics, 1)
 	// The conversion will initialize the Resource
 	md.ResourceMetrics().At(0).Resource().InitEmpty()
-	assert.Equal(t, md, pdatautil.MetricsToInternalMetrics(metrics[0]))
+	assert.Equal(t, md, pdatautil.MetricsToOldInternalMetrics(metrics[0]))
 }
 
 func TestSendMetrics_NoBackend(t *testing.T) {
@@ -207,7 +207,7 @@ func TestSendMetrics_NoBackend(t *testing.T) {
 		assert.NoError(t, exp.Shutdown(context.Background()))
 	})
 
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataOneMetric())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataOneMetric())
 	for i := 0; i < 10000; i++ {
 		assert.Error(t, exp.ConsumeMetrics(context.Background(), md))
 	}
@@ -229,6 +229,6 @@ func TestSendMetrics_AfterStop(t *testing.T) {
 	require.NoError(t, exp.Start(context.Background(), host))
 	assert.NoError(t, exp.Shutdown(context.Background()))
 
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataOneMetric())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataOneMetric())
 	assert.Error(t, exp.ConsumeMetrics(context.Background(), md))
 }

exporter/otlpexporter/otlp.go

@@ -90,7 +90,7 @@ func (e *exporterImp) pushTraceData(ctx context.Context, td pdata.Traces) (int,
 }
 
 func (e *exporterImp) pushMetricsData(ctx context.Context, md pdata.Metrics) (int, error) {
-	imd := pdatautil.MetricsToInternalMetrics(md)
+	imd := pdatautil.MetricsToOldInternalMetrics(md)
 	request := &otlpmetrics.ExportMetricsServiceRequest{
 		ResourceMetrics: dataold.MetricDataToOtlp(imd),
 	}

exporter/otlpexporter/otlp_test.go

@@ -273,7 +273,7 @@ func TestSendMetrics(t *testing.T) {
 	assert.EqualValues(t, 0, atomic.LoadInt32(&rcv.requestCount))
 
 	// Send empty trace.
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataEmpty())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataEmpty())
 	assert.NoError(t, exp.ConsumeMetrics(context.Background(), md))
 
 	// Wait until it is received.
@@ -285,7 +285,7 @@ func TestSendMetrics(t *testing.T) {
 	assert.EqualValues(t, 0, atomic.LoadInt32(&rcv.totalItems))
 
 	// A trace with 2 spans.
-	md = pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
+	md = pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
 
 	expectedOTLPReq := &otlpmetrics.ExportMetricsServiceRequest{
 		ResourceMetrics: testdataold.GenerateMetricOtlpTwoMetrics(),

processor/batchprocessor/batch_processor.go

@@ -247,7 +247,7 @@ func newBatchMetrics(nextConsumer consumer.MetricsConsumer) *batchMetrics {
 }
 
 func (bm *batchMetrics) export(ctx context.Context) error {
-	return bm.nextConsumer.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(bm.metricData))
+	return bm.nextConsumer.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(bm.metricData))
 }
 
 func (bm *batchMetrics) itemCount() uint32 {
@@ -265,7 +265,7 @@ func (bm *batchMetrics) reset() {
 }
 
 func (bm *batchMetrics) add(item interface{}) {
-	md := pdatautil.MetricsToInternalMetrics(item.(pdata.Metrics))
+	md := pdatautil.MetricsToOldInternalMetrics(item.(pdata.Metrics))
 
 	newMetricsCount := md.MetricCount()
 	if newMetricsCount == 0 {

processor/batchprocessor/batch_processor_test.go

@@ -277,13 +277,13 @@ func TestBatchMetricProcessor_ReceivingData(t *testing.T) {
 			metrics.At(metricIndex).MetricDescriptor().SetName(getTestMetricName(requestNum, metricIndex))
 		}
 		metricDataSlice = append(metricDataSlice, md.Clone())
-		pd := pdatautil.MetricsFromInternalMetrics(md)
+		pd := pdatautil.MetricsFromOldInternalMetrics(md)
 		assert.NoError(t, batcher.ConsumeMetrics(context.Background(), pd))
 	}
 
 	// Added to test case with empty resources sent.
 	md := testdataold.GenerateMetricDataEmpty()
-	assert.NoError(t, batcher.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, batcher.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	require.NoError(t, batcher.Shutdown(context.Background()))
 
@@ -325,7 +325,7 @@ func TestBatchMetricProcessor_BatchSize(t *testing.T) {
 	for requestNum := 0; requestNum < requestCount; requestNum++ {
 		md := testdataold.GenerateMetricDataManyMetricsSameResource(metricsPerRequest)
 		size += md.Size()
-		pd := pdatautil.MetricsFromInternalMetrics(md)
+		pd := pdatautil.MetricsFromOldInternalMetrics(md)
 		assert.NoError(t, batcher.ConsumeMetrics(context.Background(), pd))
 	}
 	require.NoError(t, batcher.Shutdown(context.Background()))
@@ -340,7 +340,7 @@ func TestBatchMetricProcessor_BatchSize(t *testing.T) {
 	receivedMds := sink.AllMetrics()
 	require.Equal(t, expectedBatchesNum, len(receivedMds))
 	for _, md := range receivedMds {
-		im := pdatautil.MetricsToInternalMetrics(md)
+		im := pdatautil.MetricsToOldInternalMetrics(md)
 		require.Equal(t, expectedBatchingFactor, im.ResourceMetrics().Len())
 		for i := 0; i < expectedBatchingFactor; i++ {
 			require.Equal(t, metricsPerRequest, im.ResourceMetrics().At(i).InstrumentationLibraryMetrics().At(0).Metrics().Len())
@@ -380,7 +380,7 @@ func TestBatchMetricsProcessor_Timeout(t *testing.T) {
 	start := time.Now()
 	for requestNum := 0; requestNum < requestCount; requestNum++ {
 		md := testdataold.GenerateMetricDataManyMetricsSameResource(metricsPerRequest)
-		pd := pdatautil.MetricsFromInternalMetrics(md)
+		pd := pdatautil.MetricsFromOldInternalMetrics(md)
 		assert.NoError(t, batcher.ConsumeMetrics(context.Background(), pd))
 	}
 
@@ -405,7 +405,7 @@ func TestBatchMetricsProcessor_Timeout(t *testing.T) {
 	receivedMds := sink.AllMetrics()
 	require.Equal(t, expectedBatchesNum, len(receivedMds))
 	for _, md := range receivedMds {
-		im := pdatautil.MetricsToInternalMetrics(md)
+		im := pdatautil.MetricsToOldInternalMetrics(md)
 		require.Equal(t, expectedBatchingFactor, im.ResourceMetrics().Len())
 		for i := 0; i < expectedBatchingFactor; i++ {
 			require.Equal(t, metricsPerRequest, im.ResourceMetrics().At(i).InstrumentationLibraryMetrics().At(0).Metrics().Len())
@@ -428,7 +428,7 @@ func TestBatchMetricProcessor_Shutdown(t *testing.T) {
 
 	for requestNum := 0; requestNum < requestCount; requestNum++ {
 		md := testdataold.GenerateMetricDataManyMetricsSameResource(metricsPerRequest)
-		pd := pdatautil.MetricsFromInternalMetrics(md)
+		pd := pdatautil.MetricsFromOldInternalMetrics(md)
 		assert.NoError(t, batcher.ConsumeMetrics(context.Background(), pd))
 	}
 
@@ -473,7 +473,7 @@ func spansReceivedByName(tds []pdata.Traces) map[string]pdata.Span {
 func metricsReceivedByName(mds []pdata.Metrics) map[string]dataold.Metric {
 	metricsReceivedByName := map[string]dataold.Metric{}
 	for i := range mds {
-		im := pdatautil.MetricsToInternalMetrics(mds[i])
+		im := pdatautil.MetricsToOldInternalMetrics(mds[i])
 		rms := im.ResourceMetrics()
 		for i := 0; i < rms.Len(); i++ {
 			rm := rms.At(i)

processor/cloningfanoutconnector_test.go

@@ -88,7 +88,7 @@ func TestMetricsProcessorCloningMultiplexing(t *testing.T) {
 	var wantMetricsCount = 0
 	for i := 0; i < 2; i++ {
 		wantMetricsCount += md.MetricCount()
-		err := mfc.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md))
+		err := mfc.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md))
 		if err != nil {
 			t.Errorf("Wanted nil got error")
 			return
@@ -100,15 +100,15 @@ func TestMetricsProcessorCloningMultiplexing(t *testing.T) {
 		assert.Equal(t, wantMetricsCount, m.MetricsCount())
 		metricOrig := md.ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0)
 		allMetrics := m.AllMetrics()
-		metricClone := pdatautil.MetricsToInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0)
+		metricClone := pdatautil.MetricsToOldInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).InstrumentationLibraryMetrics().At(0).Metrics().At(0)
 		if i < len(processors)-1 {
-			assert.True(t, md.ResourceMetrics().At(0).Resource() != pdatautil.MetricsToInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).Resource())
+			assert.True(t, md.ResourceMetrics().At(0).Resource() != pdatautil.MetricsToOldInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).Resource())
 			assert.True(t, metricOrig != metricClone)
 		} else {
-			assert.True(t, md.ResourceMetrics().At(0).Resource() == pdatautil.MetricsToInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).Resource())
+			assert.True(t, md.ResourceMetrics().At(0).Resource() == pdatautil.MetricsToOldInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).Resource())
 			assert.True(t, metricOrig == metricClone)
 		}
-		assert.EqualValues(t, md.ResourceMetrics().At(0).Resource(), pdatautil.MetricsToInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).Resource())
+		assert.EqualValues(t, md.ResourceMetrics().At(0).Resource(), pdatautil.MetricsToOldInternalMetrics(allMetrics[0]).ResourceMetrics().At(0).Resource())
 		assert.EqualValues(t, metricOrig, metricClone)
 	}
 }

processor/fanoutconnector_test.go

@@ -105,7 +105,7 @@ func TestMetricsProcessorMultiplexing(t *testing.T) {
 	var wantMetricsCount = 0
 	for i := 0; i < 2; i++ {
 		wantMetricsCount += md.MetricCount()
-		err := mfc.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md))
+		err := mfc.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md))
 		if err != nil {
 			t.Errorf("Wanted nil got error")
 			return
@@ -115,7 +115,7 @@ func TestMetricsProcessorMultiplexing(t *testing.T) {
 	for _, p := range processors {
 		m := p.(*exportertest.SinkMetricsExporter)
 		assert.Equal(t, wantMetricsCount, m.MetricsCount())
-		assert.EqualValues(t, md, pdatautil.MetricsToInternalMetrics(m.AllMetrics()[0]))
+		assert.EqualValues(t, md, pdatautil.MetricsToOldInternalMetrics(m.AllMetrics()[0]))
 	}
 }
 
@@ -134,7 +134,7 @@ func TestMetricsProcessorWhenOneErrors(t *testing.T) {
 	var wantMetricsCount = 0
 	for i := 0; i < 2; i++ {
 		wantMetricsCount += md.MetricCount()
-		err := mfc.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md))
+		err := mfc.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md))
 		if err == nil {
 			t.Errorf("Wanted error got nil")
 			return

processor/memorylimiter/memorylimiter_test.go

@@ -127,12 +127,12 @@ func TestMetricsMemoryPressureResponse(t *testing.T) {
 	// Below memAllocLimit.
 	currentMemAlloc = 800
 	ml.memCheck()
-	assert.NoError(t, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	// Above memAllocLimit.
 	currentMemAlloc = 1800
 	ml.memCheck()
-	assert.Equal(t, errForcedDrop, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+	assert.Equal(t, errForcedDrop, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	// Check ballast effect
 	ml.ballastSize = 1000
@@ -140,12 +140,12 @@ func TestMetricsMemoryPressureResponse(t *testing.T) {
 	// Below memAllocLimit accounting for ballast.
 	currentMemAlloc = 800 + ml.ballastSize
 	ml.memCheck()
-	assert.NoError(t, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	// Above memAllocLimit even accountiing for ballast.
 	currentMemAlloc = 1800 + ml.ballastSize
 	ml.memCheck()
-	assert.Equal(t, errForcedDrop, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+	assert.Equal(t, errForcedDrop, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	// Restore ballast to default.
 	ml.ballastSize = 0
@@ -156,12 +156,12 @@ func TestMetricsMemoryPressureResponse(t *testing.T) {
 	// Below memSpikeLimit.
 	currentMemAlloc = 500
 	ml.memCheck()
-	assert.NoError(t, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	// Above memSpikeLimit.
 	currentMemAlloc = 550
 	ml.memCheck()
-	assert.Equal(t, errForcedDrop, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md)))
+	assert.Equal(t, errForcedDrop, mp.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md)))
 
 }
 

processor/processorhelper/processor_test.go

@@ -111,7 +111,7 @@ func TestNewMetricsExporter(t *testing.T) {
 	require.NoError(t, err)
 
 	assert.NoError(t, me.Start(context.Background(), componenttest.NewNopHost()))
-	assert.NoError(t, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataEmpty())))
+	assert.NoError(t, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataEmpty())))
 	assert.NoError(t, me.Shutdown(context.Background()))
 }
 
@@ -127,13 +127,13 @@ func TestNewMetricsExporter_ProcessMetricsError(t *testing.T) {
 	want := errors.New("my_error")
 	me, err := NewMetricsProcessor(testCfg, exportertest.NewNopMetricsExporter(), newTestMProcessor(want))
 	require.NoError(t, err)
-	assert.Equal(t, want, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataEmpty())))
+	assert.Equal(t, want, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataEmpty())))
 }
 
 func TestNewMetricsExporter_ProcessMetricsErrSkipProcessingData(t *testing.T) {
 	me, err := NewMetricsProcessor(testCfg, exportertest.NewNopMetricsExporter(), newTestMProcessor(ErrSkipProcessingData))
 	require.NoError(t, err)
-	assert.Equal(t, nil, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataEmpty())))
+	assert.Equal(t, nil, me.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataEmpty())))
 }
 
 func TestNewLogsExporter(t *testing.T) {

processor/queuedprocessor/queued_processor_test.go

@@ -188,7 +188,7 @@ func TestMetricsQueueProcessor_NoEnqueueOnPermanentError(t *testing.T) {
 	require.NoError(t, err)
 	defer doneFn()
 
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
 
 	mockP := newMockConcurrentSpanProcessor()
 	mockP.updateError(consumererror.Permanent(errors.New("bad data")))
@@ -220,7 +220,7 @@ func TestMetricsQueueProcessor_NoEnqueueOnNoRetry(t *testing.T) {
 	require.NoError(t, err)
 	defer doneFn()
 
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
 
 	mockP := newMockConcurrentSpanProcessor()
 	mockP.updateError(errors.New("transient error"))
@@ -252,7 +252,7 @@ func TestMetricsQueueProcessor_EnqueueOnError(t *testing.T) {
 	require.NoError(t, err)
 	defer doneFn()
 
-	md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
+	md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
 
 	mockP := newMockConcurrentSpanProcessor()
 	mockP.updateError(errors.New("transient error"))
@@ -351,7 +351,7 @@ func TestMetricsQueueProcessorHappyPath(t *testing.T) {
 	wantBatches := 10
 	wantMetricPoints := 2 * 20
 	for i := 0; i < wantBatches; i++ {
-		md := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
+		md := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataTwoMetrics())
 		mockP.run(func() {
 			require.NoError(t, qp.ConsumeMetrics(context.Background(), md))
 		})

processor/resourceprocessor/resource_processor.go

@@ -42,7 +42,7 @@ func (rp *resourceProcessor) ProcessTraces(_ context.Context, td pdata.Traces) (
 
 // ProcessMetrics implements the MProcessor interface
 func (rp *resourceProcessor) ProcessMetrics(_ context.Context, md pdata.Metrics) (pdata.Metrics, error) {
-	imd := pdatautil.MetricsToInternalMetrics(md)
+	imd := pdatautil.MetricsToOldInternalMetrics(md)
 	rms := imd.ResourceMetrics()
 	for i := 0; i < rms.Len(); i++ {
 		resource := rms.At(i).Resource()
@@ -54,5 +54,5 @@ func (rp *resourceProcessor) ProcessMetrics(_ context.Context, md pdata.Metrics)
 		}
 		rp.attrProc.Process(resource.Attributes())
 	}
-	return pdatautil.MetricsFromInternalMetrics(imd), nil
+	return pdatautil.MetricsFromOldInternalMetrics(imd), nil
 }

processor/resourceprocessor/resource_processor_test.go

@@ -149,7 +149,7 @@ func generateTraceData(attributes map[string]string) pdata.Traces {
 func generateMetricData(attributes map[string]string) pdata.Metrics {
 	md := testdataold.GenerateMetricDataOneMetricNoResource()
 	if attributes == nil {
-		return pdatautil.MetricsFromInternalMetrics(md)
+		return pdatautil.MetricsFromOldInternalMetrics(md)
 	}
 	resource := md.ResourceMetrics().At(0).Resource()
 	resource.InitEmpty()
@@ -157,7 +157,7 @@ func generateMetricData(attributes map[string]string) pdata.Metrics {
 		resource.Attributes().InsertString(k, v)
 	}
 	resource.Attributes().Sort()
-	return pdatautil.MetricsFromInternalMetrics(md)
+	return pdatautil.MetricsFromOldInternalMetrics(md)
 }
 
 type testTraceConsumer struct {
@@ -179,7 +179,7 @@ type testMetricsConsumer struct {
 
 func (tmn *testMetricsConsumer) ConsumeMetrics(_ context.Context, md pdata.Metrics) error {
 	// sort attributes to be able to compare traces
-	imd := pdatautil.MetricsToInternalMetrics(md)
+	imd := pdatautil.MetricsToOldInternalMetrics(md)
 	for i := 0; i < imd.ResourceMetrics().Len(); i++ {
 		sortResourceAttributes(imd.ResourceMetrics().At(i).Resource())
 	}

receiver/hostmetricsreceiver/hostmetrics_receiver.go

@@ -176,7 +176,7 @@ func (hmr *receiver) scrapeMetrics(ctx context.Context) {
 		span.SetStatus(trace.Status{Code: trace.StatusCodeDataLoss, Message: fmt.Sprintf("Error(s) when scraping metrics: %v", componenterror.CombineErrors(errors))})
 	}
 
-	if err := hmr.consumer.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(metricData)); err != nil {
+	if err := hmr.consumer.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(metricData)); err != nil {
 		span.SetStatus(trace.Status{Code: trace.StatusCodeDataLoss, Message: fmt.Sprintf("Unable to process metrics: %v", err)})
 		return
 	}

receiver/hostmetricsreceiver/hostmetrics_receiver_test.go

@@ -141,7 +141,7 @@ func TestGatherMetrics_EndToEnd(t *testing.T) {
 }
 
 func assertIncludesStandardMetrics(t *testing.T, got pdata.Metrics) {
-	md := pdatautil.MetricsToInternalMetrics(got)
+	md := pdatautil.MetricsToOldInternalMetrics(got)
 
 	// get the first ResourceMetrics object
 	rms := md.ResourceMetrics()
@@ -165,7 +165,7 @@ func assertIncludesResourceMetrics(t *testing.T, got pdata.Metrics) {
 		return
 	}
 
-	md := pdatautil.MetricsToInternalMetrics(got)
+	md := pdatautil.MetricsToOldInternalMetrics(got)
 
 	// get the superset of metrics returned by all resource metrics (excluding the first)
 	returnedMetrics := make(map[string]struct{})
@@ -301,7 +301,7 @@ func TestGatherMetrics_Error(t *testing.T) {
 
 	// expect to get one empty resource metrics entry
 	require.Equal(t, 1, len(got))
-	rm := pdatautil.MetricsToInternalMetrics(got[0]).ResourceMetrics()
+	rm := pdatautil.MetricsToOldInternalMetrics(got[0]).ResourceMetrics()
 	require.Equal(t, 1, rm.Len())
 	ilm := rm.At(0).InstrumentationLibraryMetrics()
 	require.Equal(t, 1, ilm.Len())

receiver/opencensusreceiver/ocmetrics/opencensus_test.go

@@ -69,14 +69,14 @@ func TestReceiver_endToEnd(t *testing.T) {
 	}()
 
 	md := testdataold.GenerateMetricDataOneMetric()
-	assert.NoError(t, oce.ConsumeMetrics(context.Background(), pdatautil.MetricsFromInternalMetrics(md)))
+	assert.NoError(t, oce.ConsumeMetrics(context.Background(), pdatautil.MetricsFromOldInternalMetrics(md)))
 
 	testutil.WaitFor(t, func() bool {
 		return len(metricSink.AllMetrics()) != 0
 	})
 	gotMetrics := metricSink.AllMetrics()
 	require.Len(t, gotMetrics, 1)
-	gotMd := pdatautil.MetricsToInternalMetrics(gotMetrics[0])
+	gotMd := pdatautil.MetricsToOldInternalMetrics(gotMetrics[0])
 	assert.Equal(t, md, gotMd)
 }
 

receiver/otlpreceiver/metrics/otlp.go

@@ -73,7 +73,7 @@ func (r *Receiver) sendToNextConsumer(ctx context.Context, md dataold.MetricData
 	}
 
 	ctx = obsreport.StartMetricsReceiveOp(ctx, r.instanceName, receiverTransport)
-	err := r.nextConsumer.ConsumeMetrics(ctx, pdatautil.MetricsFromInternalMetrics(md))
+	err := r.nextConsumer.ConsumeMetrics(ctx, pdatautil.MetricsFromOldInternalMetrics(md))
 	obsreport.EndMetricsReceiveOp(ctx, dataFormatProtobuf, dataPointCount, metricCount, err)
 
 	return err

receiver/otlpreceiver/metrics/otlp_test.go

@@ -114,7 +114,7 @@ func TestExport(t *testing.T) {
 	require.Equal(t, 1, len(metricSink.AllMetrics()),
 		"unexpected length: %v", len(metricSink.AllMetrics()))
 
-	assert.EqualValues(t, metricData, pdatautil.MetricsToInternalMetrics(metricSink.AllMetrics()[0]))
+	assert.EqualValues(t, metricData, pdatautil.MetricsToOldInternalMetrics(metricSink.AllMetrics()[0]))
 }
 
 func TestExport_EmptyRequest(t *testing.T) {

service/builder/receivers_builder_test.go

@@ -140,7 +140,7 @@ func testReceivers(
 		traceProducer.TraceConsumer.ConsumeTraces(context.Background(), testdata.GenerateTraceDataOneSpan())
 	}
 
-	metrics := pdatautil.MetricsFromInternalMetrics(testdataold.GenerateMetricDataOneMetric())
+	metrics := pdatautil.MetricsFromOldInternalMetrics(testdataold.GenerateMetricDataOneMetric())
 	if test.hasMetrics {
 		metricsProducer := receiver.receiver.(*componenttest.ExampleReceiverProducer)
 		metricsProducer.MetricsConsumer.ConsumeMetrics(context.Background(), metrics)

testbed/correctness/metrics/metric_diff.go

@@ -38,7 +38,7 @@ func (mf MetricDiff) String() string {
 
 func pdmToPDRM(pdm []pdata.Metrics) (out []dataold.ResourceMetrics) {
 	for _, m := range pdm {
-		md := pdatautil.MetricsToInternalMetrics(m)
+		md := pdatautil.MetricsToOldInternalMetrics(m)
 		rms := md.ResourceMetrics()
 		for i := 0; i < rms.Len(); i++ {
 			rm := rms.At(i)

testbed/correctness/metrics/metric_diff_test.go

@@ -100,6 +100,6 @@ func TestSummary(t *testing.T) {
 func TestPDMToPDRM(t *testing.T) {
 	md := dataold.NewMetricData()
 	md.ResourceMetrics().Resize(1)
-	rm := pdmToPDRM([]pdata.Metrics{pdatautil.MetricsFromInternalMetrics(md)})
+	rm := pdmToPDRM([]pdata.Metrics{pdatautil.MetricsFromOldInternalMetrics(md)})
 	require.Equal(t, 1, len(rm))
 }

testbed/testbed/data_providers.go

@@ -159,7 +159,7 @@ func (dp *PerfTestDataProvider) GenerateMetrics() (pdata.Metrics, bool) {
 			})
 		}
 	}
-	return pdatautil.MetricsFromInternalMetrics(metricData), false
+	return pdatautil.MetricsFromOldInternalMetrics(metricData), false
 }
 
 func (dp *PerfTestDataProvider) GetGeneratedSpan([]byte, []byte) *otlptrace.Span {
@@ -261,7 +261,7 @@ func (dp *GoldenDataProvider) GenerateTraces() (pdata.Traces, bool) {
 }
 
 func (dp *GoldenDataProvider) GenerateMetrics() (pdata.Metrics, bool) {
-	return pdatautil.MetricsFromInternalMetrics(dataold.MetricData{}), true
+	return pdatautil.MetricsFromOldInternalMetrics(dataold.MetricData{}), true
 }
 
 func (dp *GoldenDataProvider) GenerateLogs() (pdata.Logs, bool) {

testbed/tests/resource_processor_test.go

@@ -208,7 +208,7 @@ func getResourceProcessorTestCases(t *testing.T) []resourceProcessorTestCase {
 }
 
 func getMetricDataFromResourceMetrics(rm *otlpmetrics.ResourceMetrics) pdata.Metrics {
-	return pdatautil.MetricsFromInternalMetrics(dataold.MetricDataFromOtlp([]*otlpmetrics.ResourceMetrics{rm}))
+	return pdatautil.MetricsFromOldInternalMetrics(dataold.MetricDataFromOtlp([]*otlpmetrics.ResourceMetrics{rm}))
 }
 
 func getMetricDataFromJSON(t *testing.T, rmString string) pdata.Metrics {
@@ -217,7 +217,7 @@ func getMetricDataFromJSON(t *testing.T, rmString string) pdata.Metrics {
 	err := jsonpb.UnmarshalString(rmString, &mockedResourceMetrics)
 	require.NoError(t, err, "failed to get mocked resource metrics object", err)
 
-	return pdatautil.MetricsFromInternalMetrics(dataold.MetricDataFromOtlp([]*otlpmetrics.ResourceMetrics{&mockedResourceMetrics}))
+	return pdatautil.MetricsFromOldInternalMetrics(dataold.MetricDataFromOtlp([]*otlpmetrics.ResourceMetrics{&mockedResourceMetrics}))
 }
 
 func TestMetricResourceProcessor(t *testing.T) {
@@ -280,10 +280,10 @@ func TestMetricResourceProcessor(t *testing.T) {
 
 			// Assert Resources
 			m := tc.MockBackend.ReceivedMetrics[0]
-			rm := pdatautil.MetricsToInternalMetrics(m).ResourceMetrics()
+			rm := pdatautil.MetricsToOldInternalMetrics(m).ResourceMetrics()
 			require.Equal(t, 1, rm.Len())
 
-			expectidMD := pdatautil.MetricsToInternalMetrics(test.expectedMetricData)
+			expectidMD := pdatautil.MetricsToOldInternalMetrics(test.expectedMetricData)
 			require.Equal(t,
 				attributesToMap(expectidMD.ResourceMetrics().At(0).Resource().Attributes()),
 				attributesToMap(rm.At(0).Resource().Attributes()),