diff --git a/.chloggen/fix-copy.yaml b/.chloggen/fix-copy.yaml
new file mode 100644
index 000000000000..68f030719491
--- /dev/null
+++ b/.chloggen/fix-copy.yaml
@@ -0,0 +1,25 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: bug_fix
+
+# The name of the component, or a single word describing the area of concern, (e.g. otlpreceiver)
+component: pdata
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Fix null pointer access when copying into a slice with larger cap but smaller len.
+
+# One or more tracking issues or pull requests related to the change
+issues: [13523]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]
diff --git a/internal/cmd/pdatagen/internal/templates/slice.go.tmpl b/internal/cmd/pdatagen/internal/templates/slice.go.tmpl
index b96710e9b3f9..4c2a244892d4 100644
--- a/internal/cmd/pdatagen/internal/templates/slice.go.tmpl
+++ b/internal/cmd/pdatagen/internal/templates/slice.go.tmpl
@@ -199,19 +199,41 @@ func (ms {{ .structName }}) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrig{{ .structName }}(dest, src []{{ .originElementType }}) []{{ .originElementType }} {
+	var newDest []{{ .originElementType }}
 	if cap(dest) < len(src) {
-		dest = make([]{{ .originElementType }}, len(src))
 		{{- if eq .type "sliceOfPtrs" }}
-		data := make([]{{ .originName }}, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]{{ .originElementType }}, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &{{ .originName }}{}
+		}
+		{{- else }}
+		newDest = make([]{{ .originElementType }}, len(src))
+		{{- end }}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		{{- if eq .type "sliceOfPtrs" }}
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &{{ .originName }}{}
+		}
+		{{- else }}
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = {{ .emptyOriginElement }}
 		}
 		{{- end }}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrig{{ .elementName }}({{ .originElementPtr }}dest[i], {{ .originElementPtr }}src[i])
+		copyOrig{{ .elementName }}({{ .originElementPtr }}newDest[i], {{ .originElementPtr }}src[i])
 	}
-	return dest
+	return newDest
 }
 {{- end }}
diff --git a/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl b/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl
index 26d8c8d47c3e..8e7da6122443 100644
--- a/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl
+++ b/internal/cmd/pdatagen/internal/templates/slice_internal.go.tmpl
@@ -32,20 +32,42 @@ func New{{ .structName }}(orig *[]{{ .originElementType }}, state *State) {{ .st
 }
 
 func CopyOrig{{ .structName }}(dest, src []{{ .originElementType }}) []{{ .originElementType }} {
+	var newDest []{{ .originElementType }}
 	if cap(dest) < len(src) {
-		dest = make([]{{ .originElementType }}, len(src))
 		{{- if eq .type "sliceOfPtrs" }}
-		data := make([]{{ .originName }}, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]{{ .originElementType }}, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &{{ .originName }}{}
+		}
+		{{- else }}
+		newDest = make([]{{ .originElementType }}, len(src))
+		{{- end }}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		{{- if eq .type "sliceOfPtrs" }}
+		for i := len(src); i < len(dest); i++ {
+		dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+		newDest[i] = &{{ .originName }}{}
+		}
+		{{- else }}
+		for i := len(src); i < len(dest); i++ {
+		dest[i] = {{ .emptyOriginElement }}
 		}
 		{{- end }}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		CopyOrig{{ .elementName }}({{ .originElementPtr }}dest[i], {{ .originElementPtr }}src[i])
+		CopyOrig{{ .elementName }}({{ .originElementPtr }}newDest[i], {{ .originElementPtr }}src[i])
 	}
-	return dest
+	return newDest
 }
 
 func GenerateTest{{ .structName }}() {{ .structName }} {
diff --git a/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl b/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl
index 5705b26f0237..0bb2a1750774 100644
--- a/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl
+++ b/internal/cmd/pdatagen/internal/templates/slice_test.go.tmpl
@@ -53,16 +53,25 @@ func Test{{ .structName }}ReadOnly(t *testing.T) {
 
 func Test{{ .structName }}_CopyTo(t *testing.T) {
 	dest := New{{ .structName }}()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	New{{ .structName }}().CopyTo(dest)
 	assert.Equal(t, New{{ .structName }}(), dest)
 
-	// Test CopyTo larger slice
-	generateTest{{ .structName }}().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTest{{ .structName }}()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTest{{ .structName }}(), dest)
 
 	// Test CopyTo same size slice
-	generateTest{{ .structName }}().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTest{{ .structName }}(), dest)
+}
+
+func Test{{ .structName }}_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := New{{ .structName }}()
+	src := generateTest{{ .structName }}()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTest{{ .structName }}(), dest)
 }
 
diff --git a/pdata/internal/generated_wrapper_entityrefslice.go b/pdata/internal/generated_wrapper_entityrefslice.go
index 32f4fb88b717..cac9243754bd 100644
--- a/pdata/internal/generated_wrapper_entityrefslice.go
+++ b/pdata/internal/generated_wrapper_entityrefslice.go
@@ -29,18 +29,32 @@ func NewEntityRefSlice(orig *[]*otlpcommon.EntityRef, state *State) EntityRefSli
 }
 
 func CopyOrigEntityRefSlice(dest, src []*otlpcommon.EntityRef) []*otlpcommon.EntityRef {
+	var newDest []*otlpcommon.EntityRef
 	if cap(dest) < len(src) {
-		dest = make([]*otlpcommon.EntityRef, len(src))
-		data := make([]otlpcommon.EntityRef, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpcommon.EntityRef, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpcommon.EntityRef{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpcommon.EntityRef{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		CopyOrigEntityRef(dest[i], src[i])
+		CopyOrigEntityRef(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
 
 func GenerateTestEntityRefSlice() EntityRefSlice {
diff --git a/pdata/plog/generated_logrecordslice.go b/pdata/plog/generated_logrecordslice.go
index 63e04e1416b2..8c09601b303c 100644
--- a/pdata/plog/generated_logrecordslice.go
+++ b/pdata/plog/generated_logrecordslice.go
@@ -180,16 +180,30 @@ func (ms LogRecordSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigLogRecordSlice(dest, src []*otlplogs.LogRecord) []*otlplogs.LogRecord {
+	var newDest []*otlplogs.LogRecord
 	if cap(dest) < len(src) {
-		dest = make([]*otlplogs.LogRecord, len(src))
-		data := make([]otlplogs.LogRecord, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlplogs.LogRecord, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlplogs.LogRecord{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlplogs.LogRecord{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigLogRecord(dest[i], src[i])
+		copyOrigLogRecord(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/plog/generated_logrecordslice_test.go b/pdata/plog/generated_logrecordslice_test.go
index 8db3bd8b5c7b..53079a0b0f80 100644
--- a/pdata/plog/generated_logrecordslice_test.go
+++ b/pdata/plog/generated_logrecordslice_test.go
@@ -51,16 +51,25 @@ func TestLogRecordSliceReadOnly(t *testing.T) {
 
 func TestLogRecordSlice_CopyTo(t *testing.T) {
 	dest := NewLogRecordSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewLogRecordSlice().CopyTo(dest)
 	assert.Equal(t, NewLogRecordSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestLogRecordSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestLogRecordSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLogRecordSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestLogRecordSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestLogRecordSlice(), dest)
+}
+
+func TestLogRecordSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewLogRecordSlice()
+	src := generateTestLogRecordSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLogRecordSlice(), dest)
 }
 
diff --git a/pdata/plog/generated_resourcelogsslice.go b/pdata/plog/generated_resourcelogsslice.go
index 2c40c893da9f..311f1a7a3b24 100644
--- a/pdata/plog/generated_resourcelogsslice.go
+++ b/pdata/plog/generated_resourcelogsslice.go
@@ -180,16 +180,30 @@ func (ms ResourceLogsSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigResourceLogsSlice(dest, src []*otlplogs.ResourceLogs) []*otlplogs.ResourceLogs {
+	var newDest []*otlplogs.ResourceLogs
 	if cap(dest) < len(src) {
-		dest = make([]*otlplogs.ResourceLogs, len(src))
-		data := make([]otlplogs.ResourceLogs, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlplogs.ResourceLogs, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlplogs.ResourceLogs{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlplogs.ResourceLogs{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigResourceLogs(dest[i], src[i])
+		copyOrigResourceLogs(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/plog/generated_resourcelogsslice_test.go b/pdata/plog/generated_resourcelogsslice_test.go
index 8e13e7e8ab1c..89944fbd46f1 100644
--- a/pdata/plog/generated_resourcelogsslice_test.go
+++ b/pdata/plog/generated_resourcelogsslice_test.go
@@ -51,16 +51,25 @@ func TestResourceLogsSliceReadOnly(t *testing.T) {
 
 func TestResourceLogsSlice_CopyTo(t *testing.T) {
 	dest := NewResourceLogsSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewResourceLogsSlice().CopyTo(dest)
 	assert.Equal(t, NewResourceLogsSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestResourceLogsSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestResourceLogsSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceLogsSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestResourceLogsSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestResourceLogsSlice(), dest)
+}
+
+func TestResourceLogsSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewResourceLogsSlice()
+	src := generateTestResourceLogsSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceLogsSlice(), dest)
 }
 
diff --git a/pdata/plog/generated_scopelogsslice.go b/pdata/plog/generated_scopelogsslice.go
index 0981027796b0..b9088f01e8de 100644
--- a/pdata/plog/generated_scopelogsslice.go
+++ b/pdata/plog/generated_scopelogsslice.go
@@ -180,16 +180,30 @@ func (ms ScopeLogsSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigScopeLogsSlice(dest, src []*otlplogs.ScopeLogs) []*otlplogs.ScopeLogs {
+	var newDest []*otlplogs.ScopeLogs
 	if cap(dest) < len(src) {
-		dest = make([]*otlplogs.ScopeLogs, len(src))
-		data := make([]otlplogs.ScopeLogs, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlplogs.ScopeLogs, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlplogs.ScopeLogs{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlplogs.ScopeLogs{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigScopeLogs(dest[i], src[i])
+		copyOrigScopeLogs(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/plog/generated_scopelogsslice_test.go b/pdata/plog/generated_scopelogsslice_test.go
index 698d755303b4..4c250e84fc99 100644
--- a/pdata/plog/generated_scopelogsslice_test.go
+++ b/pdata/plog/generated_scopelogsslice_test.go
@@ -51,16 +51,25 @@ func TestScopeLogsSliceReadOnly(t *testing.T) {
 
 func TestScopeLogsSlice_CopyTo(t *testing.T) {
 	dest := NewScopeLogsSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewScopeLogsSlice().CopyTo(dest)
 	assert.Equal(t, NewScopeLogsSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestScopeLogsSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestScopeLogsSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeLogsSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestScopeLogsSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestScopeLogsSlice(), dest)
+}
+
+func TestScopeLogsSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewScopeLogsSlice()
+	src := generateTestScopeLogsSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeLogsSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_exemplarslice.go b/pdata/pmetric/generated_exemplarslice.go
index 2c398fdab4c2..ca2aea31f5e8 100644
--- a/pdata/pmetric/generated_exemplarslice.go
+++ b/pdata/pmetric/generated_exemplarslice.go
@@ -171,12 +171,19 @@ func (ms ExemplarSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigExemplarSlice(dest, src []otlpmetrics.Exemplar) []otlpmetrics.Exemplar {
+	var newDest []otlpmetrics.Exemplar
 	if cap(dest) < len(src) {
-		dest = make([]otlpmetrics.Exemplar, len(src))
+		newDest = make([]otlpmetrics.Exemplar, len(src))
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = otlpmetrics.Exemplar{}
+		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigExemplar(&dest[i], &src[i])
+		copyOrigExemplar(&newDest[i], &src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_exemplarslice_test.go b/pdata/pmetric/generated_exemplarslice_test.go
index 7cc5bdc4d9f8..e4259d4069a5 100644
--- a/pdata/pmetric/generated_exemplarslice_test.go
+++ b/pdata/pmetric/generated_exemplarslice_test.go
@@ -50,16 +50,25 @@ func TestExemplarSliceReadOnly(t *testing.T) {
 
 func TestExemplarSlice_CopyTo(t *testing.T) {
 	dest := NewExemplarSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewExemplarSlice().CopyTo(dest)
 	assert.Equal(t, NewExemplarSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestExemplarSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestExemplarSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestExemplarSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestExemplarSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestExemplarSlice(), dest)
+}
+
+func TestExemplarSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewExemplarSlice()
+	src := generateTestExemplarSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestExemplarSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_exponentialhistogramdatapointslice.go b/pdata/pmetric/generated_exponentialhistogramdatapointslice.go
index b7859d428156..e6ed8a2c1027 100644
--- a/pdata/pmetric/generated_exponentialhistogramdatapointslice.go
+++ b/pdata/pmetric/generated_exponentialhistogramdatapointslice.go
@@ -180,16 +180,30 @@ func (ms ExponentialHistogramDataPointSlice) unmarshalJSONIter(iter *json.Iterat
 }
 
 func copyOrigExponentialHistogramDataPointSlice(dest, src []*otlpmetrics.ExponentialHistogramDataPoint) []*otlpmetrics.ExponentialHistogramDataPoint {
+	var newDest []*otlpmetrics.ExponentialHistogramDataPoint
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.ExponentialHistogramDataPoint, len(src))
-		data := make([]otlpmetrics.ExponentialHistogramDataPoint, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.ExponentialHistogramDataPoint, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.ExponentialHistogramDataPoint{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.ExponentialHistogramDataPoint{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigExponentialHistogramDataPoint(dest[i], src[i])
+		copyOrigExponentialHistogramDataPoint(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go b/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go
index 3996911575e4..7c51461ddd88 100644
--- a/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go
+++ b/pdata/pmetric/generated_exponentialhistogramdatapointslice_test.go
@@ -51,16 +51,25 @@ func TestExponentialHistogramDataPointSliceReadOnly(t *testing.T) {
 
 func TestExponentialHistogramDataPointSlice_CopyTo(t *testing.T) {
 	dest := NewExponentialHistogramDataPointSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewExponentialHistogramDataPointSlice().CopyTo(dest)
 	assert.Equal(t, NewExponentialHistogramDataPointSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestExponentialHistogramDataPointSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestExponentialHistogramDataPointSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestExponentialHistogramDataPointSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestExponentialHistogramDataPointSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestExponentialHistogramDataPointSlice(), dest)
+}
+
+func TestExponentialHistogramDataPointSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewExponentialHistogramDataPointSlice()
+	src := generateTestExponentialHistogramDataPointSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestExponentialHistogramDataPointSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_histogramdatapointslice.go b/pdata/pmetric/generated_histogramdatapointslice.go
index 85112ded60d1..342e19738afc 100644
--- a/pdata/pmetric/generated_histogramdatapointslice.go
+++ b/pdata/pmetric/generated_histogramdatapointslice.go
@@ -180,16 +180,30 @@ func (ms HistogramDataPointSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigHistogramDataPointSlice(dest, src []*otlpmetrics.HistogramDataPoint) []*otlpmetrics.HistogramDataPoint {
+	var newDest []*otlpmetrics.HistogramDataPoint
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.HistogramDataPoint, len(src))
-		data := make([]otlpmetrics.HistogramDataPoint, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.HistogramDataPoint, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.HistogramDataPoint{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.HistogramDataPoint{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigHistogramDataPoint(dest[i], src[i])
+		copyOrigHistogramDataPoint(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_histogramdatapointslice_test.go b/pdata/pmetric/generated_histogramdatapointslice_test.go
index 087291cc2a54..1ee2307a472f 100644
--- a/pdata/pmetric/generated_histogramdatapointslice_test.go
+++ b/pdata/pmetric/generated_histogramdatapointslice_test.go
@@ -51,16 +51,25 @@ func TestHistogramDataPointSliceReadOnly(t *testing.T) {
 
 func TestHistogramDataPointSlice_CopyTo(t *testing.T) {
 	dest := NewHistogramDataPointSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewHistogramDataPointSlice().CopyTo(dest)
 	assert.Equal(t, NewHistogramDataPointSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestHistogramDataPointSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestHistogramDataPointSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestHistogramDataPointSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestHistogramDataPointSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestHistogramDataPointSlice(), dest)
+}
+
+func TestHistogramDataPointSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewHistogramDataPointSlice()
+	src := generateTestHistogramDataPointSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestHistogramDataPointSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_metricslice.go b/pdata/pmetric/generated_metricslice.go
index fcd213a5dc2f..694a7fbafcb0 100644
--- a/pdata/pmetric/generated_metricslice.go
+++ b/pdata/pmetric/generated_metricslice.go
@@ -180,16 +180,30 @@ func (ms MetricSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigMetricSlice(dest, src []*otlpmetrics.Metric) []*otlpmetrics.Metric {
+	var newDest []*otlpmetrics.Metric
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.Metric, len(src))
-		data := make([]otlpmetrics.Metric, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.Metric, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.Metric{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.Metric{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigMetric(dest[i], src[i])
+		copyOrigMetric(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_metricslice_test.go b/pdata/pmetric/generated_metricslice_test.go
index 8f7fd989d5f1..935c97f4cce1 100644
--- a/pdata/pmetric/generated_metricslice_test.go
+++ b/pdata/pmetric/generated_metricslice_test.go
@@ -51,16 +51,25 @@ func TestMetricSliceReadOnly(t *testing.T) {
 
 func TestMetricSlice_CopyTo(t *testing.T) {
 	dest := NewMetricSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewMetricSlice().CopyTo(dest)
 	assert.Equal(t, NewMetricSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestMetricSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestMetricSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestMetricSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestMetricSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestMetricSlice(), dest)
+}
+
+func TestMetricSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewMetricSlice()
+	src := generateTestMetricSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestMetricSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_numberdatapointslice.go b/pdata/pmetric/generated_numberdatapointslice.go
index a8bc871220c7..c6286fce6118 100644
--- a/pdata/pmetric/generated_numberdatapointslice.go
+++ b/pdata/pmetric/generated_numberdatapointslice.go
@@ -180,16 +180,30 @@ func (ms NumberDataPointSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigNumberDataPointSlice(dest, src []*otlpmetrics.NumberDataPoint) []*otlpmetrics.NumberDataPoint {
+	var newDest []*otlpmetrics.NumberDataPoint
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.NumberDataPoint, len(src))
-		data := make([]otlpmetrics.NumberDataPoint, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.NumberDataPoint, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.NumberDataPoint{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.NumberDataPoint{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigNumberDataPoint(dest[i], src[i])
+		copyOrigNumberDataPoint(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_numberdatapointslice_test.go b/pdata/pmetric/generated_numberdatapointslice_test.go
index 1d6651aaae5f..a7da42fbbd07 100644
--- a/pdata/pmetric/generated_numberdatapointslice_test.go
+++ b/pdata/pmetric/generated_numberdatapointslice_test.go
@@ -51,16 +51,25 @@ func TestNumberDataPointSliceReadOnly(t *testing.T) {
 
 func TestNumberDataPointSlice_CopyTo(t *testing.T) {
 	dest := NewNumberDataPointSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewNumberDataPointSlice().CopyTo(dest)
 	assert.Equal(t, NewNumberDataPointSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestNumberDataPointSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestNumberDataPointSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestNumberDataPointSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestNumberDataPointSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestNumberDataPointSlice(), dest)
+}
+
+func TestNumberDataPointSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewNumberDataPointSlice()
+	src := generateTestNumberDataPointSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestNumberDataPointSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_resourcemetricsslice.go b/pdata/pmetric/generated_resourcemetricsslice.go
index 41c5ff0d0a16..3c2e6aa7ca58 100644
--- a/pdata/pmetric/generated_resourcemetricsslice.go
+++ b/pdata/pmetric/generated_resourcemetricsslice.go
@@ -180,16 +180,30 @@ func (ms ResourceMetricsSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigResourceMetricsSlice(dest, src []*otlpmetrics.ResourceMetrics) []*otlpmetrics.ResourceMetrics {
+	var newDest []*otlpmetrics.ResourceMetrics
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.ResourceMetrics, len(src))
-		data := make([]otlpmetrics.ResourceMetrics, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.ResourceMetrics, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.ResourceMetrics{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.ResourceMetrics{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigResourceMetrics(dest[i], src[i])
+		copyOrigResourceMetrics(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_resourcemetricsslice_test.go b/pdata/pmetric/generated_resourcemetricsslice_test.go
index d50ac8e1d2cb..9a4a53a88828 100644
--- a/pdata/pmetric/generated_resourcemetricsslice_test.go
+++ b/pdata/pmetric/generated_resourcemetricsslice_test.go
@@ -51,16 +51,25 @@ func TestResourceMetricsSliceReadOnly(t *testing.T) {
 
 func TestResourceMetricsSlice_CopyTo(t *testing.T) {
 	dest := NewResourceMetricsSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewResourceMetricsSlice().CopyTo(dest)
 	assert.Equal(t, NewResourceMetricsSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestResourceMetricsSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestResourceMetricsSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceMetricsSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestResourceMetricsSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestResourceMetricsSlice(), dest)
+}
+
+func TestResourceMetricsSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewResourceMetricsSlice()
+	src := generateTestResourceMetricsSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceMetricsSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_scopemetricsslice.go b/pdata/pmetric/generated_scopemetricsslice.go
index 6a3a83a69a11..9136c4af41ff 100644
--- a/pdata/pmetric/generated_scopemetricsslice.go
+++ b/pdata/pmetric/generated_scopemetricsslice.go
@@ -180,16 +180,30 @@ func (ms ScopeMetricsSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigScopeMetricsSlice(dest, src []*otlpmetrics.ScopeMetrics) []*otlpmetrics.ScopeMetrics {
+	var newDest []*otlpmetrics.ScopeMetrics
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.ScopeMetrics, len(src))
-		data := make([]otlpmetrics.ScopeMetrics, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.ScopeMetrics, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.ScopeMetrics{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.ScopeMetrics{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigScopeMetrics(dest[i], src[i])
+		copyOrigScopeMetrics(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_scopemetricsslice_test.go b/pdata/pmetric/generated_scopemetricsslice_test.go
index e5cacff9f493..c583e1611756 100644
--- a/pdata/pmetric/generated_scopemetricsslice_test.go
+++ b/pdata/pmetric/generated_scopemetricsslice_test.go
@@ -51,16 +51,25 @@ func TestScopeMetricsSliceReadOnly(t *testing.T) {
 
 func TestScopeMetricsSlice_CopyTo(t *testing.T) {
 	dest := NewScopeMetricsSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewScopeMetricsSlice().CopyTo(dest)
 	assert.Equal(t, NewScopeMetricsSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestScopeMetricsSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestScopeMetricsSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeMetricsSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestScopeMetricsSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestScopeMetricsSlice(), dest)
+}
+
+func TestScopeMetricsSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewScopeMetricsSlice()
+	src := generateTestScopeMetricsSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeMetricsSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_summarydatapointslice.go b/pdata/pmetric/generated_summarydatapointslice.go
index 0bd836b1fb5c..ecc20677681c 100644
--- a/pdata/pmetric/generated_summarydatapointslice.go
+++ b/pdata/pmetric/generated_summarydatapointslice.go
@@ -180,16 +180,30 @@ func (ms SummaryDataPointSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigSummaryDataPointSlice(dest, src []*otlpmetrics.SummaryDataPoint) []*otlpmetrics.SummaryDataPoint {
+	var newDest []*otlpmetrics.SummaryDataPoint
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.SummaryDataPoint, len(src))
-		data := make([]otlpmetrics.SummaryDataPoint, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.SummaryDataPoint, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.SummaryDataPoint{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.SummaryDataPoint{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigSummaryDataPoint(dest[i], src[i])
+		copyOrigSummaryDataPoint(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_summarydatapointslice_test.go b/pdata/pmetric/generated_summarydatapointslice_test.go
index e48edb1dc023..ef6509a7a8c4 100644
--- a/pdata/pmetric/generated_summarydatapointslice_test.go
+++ b/pdata/pmetric/generated_summarydatapointslice_test.go
@@ -51,16 +51,25 @@ func TestSummaryDataPointSliceReadOnly(t *testing.T) {
 
 func TestSummaryDataPointSlice_CopyTo(t *testing.T) {
 	dest := NewSummaryDataPointSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewSummaryDataPointSlice().CopyTo(dest)
 	assert.Equal(t, NewSummaryDataPointSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestSummaryDataPointSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestSummaryDataPointSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSummaryDataPointSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestSummaryDataPointSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestSummaryDataPointSlice(), dest)
+}
+
+func TestSummaryDataPointSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSummaryDataPointSlice()
+	src := generateTestSummaryDataPointSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSummaryDataPointSlice(), dest)
 }
 
diff --git a/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go b/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go
index 5b31ec588fb2..0b5326ab3a8f 100644
--- a/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go
+++ b/pdata/pmetric/generated_summarydatapointvalueatquantileslice.go
@@ -180,16 +180,30 @@ func (ms SummaryDataPointValueAtQuantileSlice) unmarshalJSONIter(iter *json.Iter
 }
 
 func copyOrigSummaryDataPointValueAtQuantileSlice(dest, src []*otlpmetrics.SummaryDataPoint_ValueAtQuantile) []*otlpmetrics.SummaryDataPoint_ValueAtQuantile {
+	var newDest []*otlpmetrics.SummaryDataPoint_ValueAtQuantile
 	if cap(dest) < len(src) {
-		dest = make([]*otlpmetrics.SummaryDataPoint_ValueAtQuantile, len(src))
-		data := make([]otlpmetrics.SummaryDataPoint_ValueAtQuantile, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpmetrics.SummaryDataPoint_ValueAtQuantile, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpmetrics.SummaryDataPoint_ValueAtQuantile{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigSummaryDataPointValueAtQuantile(dest[i], src[i])
+		copyOrigSummaryDataPointValueAtQuantile(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go b/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go
index 900b31e10e48..a04ef9ea89a4 100644
--- a/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go
+++ b/pdata/pmetric/generated_summarydatapointvalueatquantileslice_test.go
@@ -51,16 +51,25 @@ func TestSummaryDataPointValueAtQuantileSliceReadOnly(t *testing.T) {
 
 func TestSummaryDataPointValueAtQuantileSlice_CopyTo(t *testing.T) {
 	dest := NewSummaryDataPointValueAtQuantileSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewSummaryDataPointValueAtQuantileSlice().CopyTo(dest)
 	assert.Equal(t, NewSummaryDataPointValueAtQuantileSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestSummaryDataPointValueAtQuantileSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestSummaryDataPointValueAtQuantileSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSummaryDataPointValueAtQuantileSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestSummaryDataPointValueAtQuantileSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestSummaryDataPointValueAtQuantileSlice(), dest)
+}
+
+func TestSummaryDataPointValueAtQuantileSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSummaryDataPointValueAtQuantileSlice()
+	src := generateTestSummaryDataPointValueAtQuantileSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSummaryDataPointValueAtQuantileSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_attributetableslice.go b/pdata/pprofile/generated_attributetableslice.go
index 66f3a198ecd8..78bc3abc1ec9 100644
--- a/pdata/pprofile/generated_attributetableslice.go
+++ b/pdata/pprofile/generated_attributetableslice.go
@@ -171,12 +171,19 @@ func (ms AttributeTableSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigAttributeTableSlice(dest, src []v1.KeyValue) []v1.KeyValue {
+	var newDest []v1.KeyValue
 	if cap(dest) < len(src) {
-		dest = make([]v1.KeyValue, len(src))
+		newDest = make([]v1.KeyValue, len(src))
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = v1.KeyValue{}
+		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigAttribute(&dest[i], &src[i])
+		copyOrigAttribute(&newDest[i], &src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_attributetableslice_test.go b/pdata/pprofile/generated_attributetableslice_test.go
index b162e4bef135..e76c4a5dab31 100644
--- a/pdata/pprofile/generated_attributetableslice_test.go
+++ b/pdata/pprofile/generated_attributetableslice_test.go
@@ -50,16 +50,25 @@ func TestAttributeTableSliceReadOnly(t *testing.T) {
 
 func TestAttributeTableSlice_CopyTo(t *testing.T) {
 	dest := NewAttributeTableSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewAttributeTableSlice().CopyTo(dest)
 	assert.Equal(t, NewAttributeTableSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestAttributeTableSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestAttributeTableSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestAttributeTableSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestAttributeTableSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestAttributeTableSlice(), dest)
+}
+
+func TestAttributeTableSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewAttributeTableSlice()
+	src := generateTestAttributeTableSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestAttributeTableSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_attributeunitslice.go b/pdata/pprofile/generated_attributeunitslice.go
index 7ca6de07bc66..57969d76a8e4 100644
--- a/pdata/pprofile/generated_attributeunitslice.go
+++ b/pdata/pprofile/generated_attributeunitslice.go
@@ -180,16 +180,30 @@ func (ms AttributeUnitSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigAttributeUnitSlice(dest, src []*otlpprofiles.AttributeUnit) []*otlpprofiles.AttributeUnit {
+	var newDest []*otlpprofiles.AttributeUnit
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.AttributeUnit, len(src))
-		data := make([]otlpprofiles.AttributeUnit, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.AttributeUnit, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.AttributeUnit{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.AttributeUnit{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigAttributeUnit(dest[i], src[i])
+		copyOrigAttributeUnit(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_attributeunitslice_test.go b/pdata/pprofile/generated_attributeunitslice_test.go
index dd0a129262bd..8ded5a189198 100644
--- a/pdata/pprofile/generated_attributeunitslice_test.go
+++ b/pdata/pprofile/generated_attributeunitslice_test.go
@@ -51,16 +51,25 @@ func TestAttributeUnitSliceReadOnly(t *testing.T) {
 
 func TestAttributeUnitSlice_CopyTo(t *testing.T) {
 	dest := NewAttributeUnitSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewAttributeUnitSlice().CopyTo(dest)
 	assert.Equal(t, NewAttributeUnitSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestAttributeUnitSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestAttributeUnitSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestAttributeUnitSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestAttributeUnitSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestAttributeUnitSlice(), dest)
+}
+
+func TestAttributeUnitSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewAttributeUnitSlice()
+	src := generateTestAttributeUnitSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestAttributeUnitSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_functionslice.go b/pdata/pprofile/generated_functionslice.go
index 0b5a86060c6b..20df6846fdd3 100644
--- a/pdata/pprofile/generated_functionslice.go
+++ b/pdata/pprofile/generated_functionslice.go
@@ -180,16 +180,30 @@ func (ms FunctionSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigFunctionSlice(dest, src []*otlpprofiles.Function) []*otlpprofiles.Function {
+	var newDest []*otlpprofiles.Function
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Function, len(src))
-		data := make([]otlpprofiles.Function, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Function, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Function{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Function{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigFunction(dest[i], src[i])
+		copyOrigFunction(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_functionslice_test.go b/pdata/pprofile/generated_functionslice_test.go
index 4501aa253e47..5d7824514fbe 100644
--- a/pdata/pprofile/generated_functionslice_test.go
+++ b/pdata/pprofile/generated_functionslice_test.go
@@ -51,16 +51,25 @@ func TestFunctionSliceReadOnly(t *testing.T) {
 
 func TestFunctionSlice_CopyTo(t *testing.T) {
 	dest := NewFunctionSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewFunctionSlice().CopyTo(dest)
 	assert.Equal(t, NewFunctionSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestFunctionSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestFunctionSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestFunctionSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestFunctionSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestFunctionSlice(), dest)
+}
+
+func TestFunctionSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewFunctionSlice()
+	src := generateTestFunctionSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestFunctionSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_lineslice.go b/pdata/pprofile/generated_lineslice.go
index cd22a1728646..8c4502e10b9d 100644
--- a/pdata/pprofile/generated_lineslice.go
+++ b/pdata/pprofile/generated_lineslice.go
@@ -180,16 +180,30 @@ func (ms LineSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigLineSlice(dest, src []*otlpprofiles.Line) []*otlpprofiles.Line {
+	var newDest []*otlpprofiles.Line
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Line, len(src))
-		data := make([]otlpprofiles.Line, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Line, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Line{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Line{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigLine(dest[i], src[i])
+		copyOrigLine(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_lineslice_test.go b/pdata/pprofile/generated_lineslice_test.go
index 084cac88ec01..eac1d8b3a79a 100644
--- a/pdata/pprofile/generated_lineslice_test.go
+++ b/pdata/pprofile/generated_lineslice_test.go
@@ -51,16 +51,25 @@ func TestLineSliceReadOnly(t *testing.T) {
 
 func TestLineSlice_CopyTo(t *testing.T) {
 	dest := NewLineSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewLineSlice().CopyTo(dest)
 	assert.Equal(t, NewLineSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestLineSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestLineSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLineSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestLineSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestLineSlice(), dest)
+}
+
+func TestLineSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewLineSlice()
+	src := generateTestLineSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLineSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_linkslice.go b/pdata/pprofile/generated_linkslice.go
index f38e2bf95a9c..40d84a68719e 100644
--- a/pdata/pprofile/generated_linkslice.go
+++ b/pdata/pprofile/generated_linkslice.go
@@ -180,16 +180,30 @@ func (ms LinkSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigLinkSlice(dest, src []*otlpprofiles.Link) []*otlpprofiles.Link {
+	var newDest []*otlpprofiles.Link
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Link, len(src))
-		data := make([]otlpprofiles.Link, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Link, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Link{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Link{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigLink(dest[i], src[i])
+		copyOrigLink(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_linkslice_test.go b/pdata/pprofile/generated_linkslice_test.go
index 019f3f65b2f8..7398bc7d2a8b 100644
--- a/pdata/pprofile/generated_linkslice_test.go
+++ b/pdata/pprofile/generated_linkslice_test.go
@@ -51,16 +51,25 @@ func TestLinkSliceReadOnly(t *testing.T) {
 
 func TestLinkSlice_CopyTo(t *testing.T) {
 	dest := NewLinkSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewLinkSlice().CopyTo(dest)
 	assert.Equal(t, NewLinkSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestLinkSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestLinkSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLinkSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestLinkSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestLinkSlice(), dest)
+}
+
+func TestLinkSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewLinkSlice()
+	src := generateTestLinkSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLinkSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_locationslice.go b/pdata/pprofile/generated_locationslice.go
index c7465c77ad53..1a2353247cdf 100644
--- a/pdata/pprofile/generated_locationslice.go
+++ b/pdata/pprofile/generated_locationslice.go
@@ -180,16 +180,30 @@ func (ms LocationSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigLocationSlice(dest, src []*otlpprofiles.Location) []*otlpprofiles.Location {
+	var newDest []*otlpprofiles.Location
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Location, len(src))
-		data := make([]otlpprofiles.Location, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Location, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Location{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Location{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigLocation(dest[i], src[i])
+		copyOrigLocation(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_locationslice_test.go b/pdata/pprofile/generated_locationslice_test.go
index 271e7e639914..5674591d1cf2 100644
--- a/pdata/pprofile/generated_locationslice_test.go
+++ b/pdata/pprofile/generated_locationslice_test.go
@@ -51,16 +51,25 @@ func TestLocationSliceReadOnly(t *testing.T) {
 
 func TestLocationSlice_CopyTo(t *testing.T) {
 	dest := NewLocationSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewLocationSlice().CopyTo(dest)
 	assert.Equal(t, NewLocationSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestLocationSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestLocationSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLocationSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestLocationSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestLocationSlice(), dest)
+}
+
+func TestLocationSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewLocationSlice()
+	src := generateTestLocationSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestLocationSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_mappingslice.go b/pdata/pprofile/generated_mappingslice.go
index 6f201bb9de10..cf3a7e290f43 100644
--- a/pdata/pprofile/generated_mappingslice.go
+++ b/pdata/pprofile/generated_mappingslice.go
@@ -180,16 +180,30 @@ func (ms MappingSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigMappingSlice(dest, src []*otlpprofiles.Mapping) []*otlpprofiles.Mapping {
+	var newDest []*otlpprofiles.Mapping
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Mapping, len(src))
-		data := make([]otlpprofiles.Mapping, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Mapping, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Mapping{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Mapping{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigMapping(dest[i], src[i])
+		copyOrigMapping(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_mappingslice_test.go b/pdata/pprofile/generated_mappingslice_test.go
index 374de0d98f8d..595a5d39ab58 100644
--- a/pdata/pprofile/generated_mappingslice_test.go
+++ b/pdata/pprofile/generated_mappingslice_test.go
@@ -51,16 +51,25 @@ func TestMappingSliceReadOnly(t *testing.T) {
 
 func TestMappingSlice_CopyTo(t *testing.T) {
 	dest := NewMappingSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewMappingSlice().CopyTo(dest)
 	assert.Equal(t, NewMappingSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestMappingSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestMappingSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestMappingSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestMappingSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestMappingSlice(), dest)
+}
+
+func TestMappingSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewMappingSlice()
+	src := generateTestMappingSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestMappingSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_profilesslice.go b/pdata/pprofile/generated_profilesslice.go
index 2410dfa563a1..9c6e7f5ffc5d 100644
--- a/pdata/pprofile/generated_profilesslice.go
+++ b/pdata/pprofile/generated_profilesslice.go
@@ -180,16 +180,30 @@ func (ms ProfilesSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigProfilesSlice(dest, src []*otlpprofiles.Profile) []*otlpprofiles.Profile {
+	var newDest []*otlpprofiles.Profile
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Profile, len(src))
-		data := make([]otlpprofiles.Profile, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Profile, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Profile{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Profile{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigProfile(dest[i], src[i])
+		copyOrigProfile(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_profilesslice_test.go b/pdata/pprofile/generated_profilesslice_test.go
index 33edb9d19b15..dd4174e50820 100644
--- a/pdata/pprofile/generated_profilesslice_test.go
+++ b/pdata/pprofile/generated_profilesslice_test.go
@@ -51,16 +51,25 @@ func TestProfilesSliceReadOnly(t *testing.T) {
 
 func TestProfilesSlice_CopyTo(t *testing.T) {
 	dest := NewProfilesSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewProfilesSlice().CopyTo(dest)
 	assert.Equal(t, NewProfilesSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestProfilesSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestProfilesSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestProfilesSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestProfilesSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestProfilesSlice(), dest)
+}
+
+func TestProfilesSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewProfilesSlice()
+	src := generateTestProfilesSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestProfilesSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_resourceprofilesslice.go b/pdata/pprofile/generated_resourceprofilesslice.go
index f33709b7521c..69f2ad888b5a 100644
--- a/pdata/pprofile/generated_resourceprofilesslice.go
+++ b/pdata/pprofile/generated_resourceprofilesslice.go
@@ -180,16 +180,30 @@ func (ms ResourceProfilesSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigResourceProfilesSlice(dest, src []*otlpprofiles.ResourceProfiles) []*otlpprofiles.ResourceProfiles {
+	var newDest []*otlpprofiles.ResourceProfiles
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.ResourceProfiles, len(src))
-		data := make([]otlpprofiles.ResourceProfiles, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.ResourceProfiles, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.ResourceProfiles{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.ResourceProfiles{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigResourceProfiles(dest[i], src[i])
+		copyOrigResourceProfiles(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_resourceprofilesslice_test.go b/pdata/pprofile/generated_resourceprofilesslice_test.go
index 731336fc18b9..7ff599194e53 100644
--- a/pdata/pprofile/generated_resourceprofilesslice_test.go
+++ b/pdata/pprofile/generated_resourceprofilesslice_test.go
@@ -51,16 +51,25 @@ func TestResourceProfilesSliceReadOnly(t *testing.T) {
 
 func TestResourceProfilesSlice_CopyTo(t *testing.T) {
 	dest := NewResourceProfilesSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewResourceProfilesSlice().CopyTo(dest)
 	assert.Equal(t, NewResourceProfilesSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestResourceProfilesSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestResourceProfilesSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceProfilesSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestResourceProfilesSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestResourceProfilesSlice(), dest)
+}
+
+func TestResourceProfilesSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewResourceProfilesSlice()
+	src := generateTestResourceProfilesSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceProfilesSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_sampleslice.go b/pdata/pprofile/generated_sampleslice.go
index 5284fa01f1d6..fbb1866e1e13 100644
--- a/pdata/pprofile/generated_sampleslice.go
+++ b/pdata/pprofile/generated_sampleslice.go
@@ -180,16 +180,30 @@ func (ms SampleSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigSampleSlice(dest, src []*otlpprofiles.Sample) []*otlpprofiles.Sample {
+	var newDest []*otlpprofiles.Sample
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.Sample, len(src))
-		data := make([]otlpprofiles.Sample, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.Sample, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Sample{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.Sample{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigSample(dest[i], src[i])
+		copyOrigSample(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_sampleslice_test.go b/pdata/pprofile/generated_sampleslice_test.go
index 9232d07326af..108803280950 100644
--- a/pdata/pprofile/generated_sampleslice_test.go
+++ b/pdata/pprofile/generated_sampleslice_test.go
@@ -51,16 +51,25 @@ func TestSampleSliceReadOnly(t *testing.T) {
 
 func TestSampleSlice_CopyTo(t *testing.T) {
 	dest := NewSampleSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewSampleSlice().CopyTo(dest)
 	assert.Equal(t, NewSampleSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestSampleSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestSampleSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSampleSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestSampleSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestSampleSlice(), dest)
+}
+
+func TestSampleSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSampleSlice()
+	src := generateTestSampleSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSampleSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_scopeprofilesslice.go b/pdata/pprofile/generated_scopeprofilesslice.go
index 50214573b4a4..1561bb00321c 100644
--- a/pdata/pprofile/generated_scopeprofilesslice.go
+++ b/pdata/pprofile/generated_scopeprofilesslice.go
@@ -180,16 +180,30 @@ func (ms ScopeProfilesSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigScopeProfilesSlice(dest, src []*otlpprofiles.ScopeProfiles) []*otlpprofiles.ScopeProfiles {
+	var newDest []*otlpprofiles.ScopeProfiles
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.ScopeProfiles, len(src))
-		data := make([]otlpprofiles.ScopeProfiles, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.ScopeProfiles, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.ScopeProfiles{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.ScopeProfiles{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigScopeProfiles(dest[i], src[i])
+		copyOrigScopeProfiles(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_scopeprofilesslice_test.go b/pdata/pprofile/generated_scopeprofilesslice_test.go
index ccda430068e3..234b5fd97e05 100644
--- a/pdata/pprofile/generated_scopeprofilesslice_test.go
+++ b/pdata/pprofile/generated_scopeprofilesslice_test.go
@@ -51,16 +51,25 @@ func TestScopeProfilesSliceReadOnly(t *testing.T) {
 
 func TestScopeProfilesSlice_CopyTo(t *testing.T) {
 	dest := NewScopeProfilesSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewScopeProfilesSlice().CopyTo(dest)
 	assert.Equal(t, NewScopeProfilesSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestScopeProfilesSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestScopeProfilesSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeProfilesSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestScopeProfilesSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestScopeProfilesSlice(), dest)
+}
+
+func TestScopeProfilesSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewScopeProfilesSlice()
+	src := generateTestScopeProfilesSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeProfilesSlice(), dest)
 }
 
diff --git a/pdata/pprofile/generated_valuetypeslice.go b/pdata/pprofile/generated_valuetypeslice.go
index d769171735b4..653fd2d6adef 100644
--- a/pdata/pprofile/generated_valuetypeslice.go
+++ b/pdata/pprofile/generated_valuetypeslice.go
@@ -180,16 +180,30 @@ func (ms ValueTypeSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigValueTypeSlice(dest, src []*otlpprofiles.ValueType) []*otlpprofiles.ValueType {
+	var newDest []*otlpprofiles.ValueType
 	if cap(dest) < len(src) {
-		dest = make([]*otlpprofiles.ValueType, len(src))
-		data := make([]otlpprofiles.ValueType, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlpprofiles.ValueType, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.ValueType{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlpprofiles.ValueType{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigValueType(dest[i], src[i])
+		copyOrigValueType(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/pprofile/generated_valuetypeslice_test.go b/pdata/pprofile/generated_valuetypeslice_test.go
index 7cda1a8079a5..2bb0245e190e 100644
--- a/pdata/pprofile/generated_valuetypeslice_test.go
+++ b/pdata/pprofile/generated_valuetypeslice_test.go
@@ -51,16 +51,25 @@ func TestValueTypeSliceReadOnly(t *testing.T) {
 
 func TestValueTypeSlice_CopyTo(t *testing.T) {
 	dest := NewValueTypeSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewValueTypeSlice().CopyTo(dest)
 	assert.Equal(t, NewValueTypeSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestValueTypeSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestValueTypeSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestValueTypeSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestValueTypeSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestValueTypeSlice(), dest)
+}
+
+func TestValueTypeSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewValueTypeSlice()
+	src := generateTestValueTypeSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestValueTypeSlice(), dest)
 }
 
diff --git a/pdata/ptrace/generated_resourcespansslice.go b/pdata/ptrace/generated_resourcespansslice.go
index 857d5f52bb84..79acb8c43766 100644
--- a/pdata/ptrace/generated_resourcespansslice.go
+++ b/pdata/ptrace/generated_resourcespansslice.go
@@ -180,16 +180,30 @@ func (ms ResourceSpansSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigResourceSpansSlice(dest, src []*otlptrace.ResourceSpans) []*otlptrace.ResourceSpans {
+	var newDest []*otlptrace.ResourceSpans
 	if cap(dest) < len(src) {
-		dest = make([]*otlptrace.ResourceSpans, len(src))
-		data := make([]otlptrace.ResourceSpans, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlptrace.ResourceSpans, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.ResourceSpans{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.ResourceSpans{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigResourceSpans(dest[i], src[i])
+		copyOrigResourceSpans(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/ptrace/generated_resourcespansslice_test.go b/pdata/ptrace/generated_resourcespansslice_test.go
index 18cd82ac06c0..a36a27491066 100644
--- a/pdata/ptrace/generated_resourcespansslice_test.go
+++ b/pdata/ptrace/generated_resourcespansslice_test.go
@@ -51,16 +51,25 @@ func TestResourceSpansSliceReadOnly(t *testing.T) {
 
 func TestResourceSpansSlice_CopyTo(t *testing.T) {
 	dest := NewResourceSpansSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewResourceSpansSlice().CopyTo(dest)
 	assert.Equal(t, NewResourceSpansSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestResourceSpansSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestResourceSpansSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceSpansSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestResourceSpansSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestResourceSpansSlice(), dest)
+}
+
+func TestResourceSpansSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewResourceSpansSlice()
+	src := generateTestResourceSpansSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestResourceSpansSlice(), dest)
 }
 
diff --git a/pdata/ptrace/generated_scopespansslice.go b/pdata/ptrace/generated_scopespansslice.go
index a5ba641b445d..882c2a1f49bc 100644
--- a/pdata/ptrace/generated_scopespansslice.go
+++ b/pdata/ptrace/generated_scopespansslice.go
@@ -180,16 +180,30 @@ func (ms ScopeSpansSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigScopeSpansSlice(dest, src []*otlptrace.ScopeSpans) []*otlptrace.ScopeSpans {
+	var newDest []*otlptrace.ScopeSpans
 	if cap(dest) < len(src) {
-		dest = make([]*otlptrace.ScopeSpans, len(src))
-		data := make([]otlptrace.ScopeSpans, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlptrace.ScopeSpans, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.ScopeSpans{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.ScopeSpans{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigScopeSpans(dest[i], src[i])
+		copyOrigScopeSpans(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/ptrace/generated_scopespansslice_test.go b/pdata/ptrace/generated_scopespansslice_test.go
index 71463d39ab12..b762955eacd6 100644
--- a/pdata/ptrace/generated_scopespansslice_test.go
+++ b/pdata/ptrace/generated_scopespansslice_test.go
@@ -51,16 +51,25 @@ func TestScopeSpansSliceReadOnly(t *testing.T) {
 
 func TestScopeSpansSlice_CopyTo(t *testing.T) {
 	dest := NewScopeSpansSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewScopeSpansSlice().CopyTo(dest)
 	assert.Equal(t, NewScopeSpansSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestScopeSpansSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestScopeSpansSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeSpansSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestScopeSpansSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestScopeSpansSlice(), dest)
+}
+
+func TestScopeSpansSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewScopeSpansSlice()
+	src := generateTestScopeSpansSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestScopeSpansSlice(), dest)
 }
 
diff --git a/pdata/ptrace/generated_spaneventslice.go b/pdata/ptrace/generated_spaneventslice.go
index d87d14482bc2..eef081ab2a4a 100644
--- a/pdata/ptrace/generated_spaneventslice.go
+++ b/pdata/ptrace/generated_spaneventslice.go
@@ -180,16 +180,30 @@ func (ms SpanEventSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigSpanEventSlice(dest, src []*otlptrace.Span_Event) []*otlptrace.Span_Event {
+	var newDest []*otlptrace.Span_Event
 	if cap(dest) < len(src) {
-		dest = make([]*otlptrace.Span_Event, len(src))
-		data := make([]otlptrace.Span_Event, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlptrace.Span_Event, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.Span_Event{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.Span_Event{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigSpanEvent(dest[i], src[i])
+		copyOrigSpanEvent(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/ptrace/generated_spaneventslice_test.go b/pdata/ptrace/generated_spaneventslice_test.go
index a627156fa21b..841a11852738 100644
--- a/pdata/ptrace/generated_spaneventslice_test.go
+++ b/pdata/ptrace/generated_spaneventslice_test.go
@@ -51,16 +51,25 @@ func TestSpanEventSliceReadOnly(t *testing.T) {
 
 func TestSpanEventSlice_CopyTo(t *testing.T) {
 	dest := NewSpanEventSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewSpanEventSlice().CopyTo(dest)
 	assert.Equal(t, NewSpanEventSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestSpanEventSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestSpanEventSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSpanEventSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestSpanEventSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestSpanEventSlice(), dest)
+}
+
+func TestSpanEventSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSpanEventSlice()
+	src := generateTestSpanEventSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSpanEventSlice(), dest)
 }
 
diff --git a/pdata/ptrace/generated_spanlinkslice.go b/pdata/ptrace/generated_spanlinkslice.go
index 2aa1d2255a80..4a00ee672ff3 100644
--- a/pdata/ptrace/generated_spanlinkslice.go
+++ b/pdata/ptrace/generated_spanlinkslice.go
@@ -180,16 +180,30 @@ func (ms SpanLinkSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigSpanLinkSlice(dest, src []*otlptrace.Span_Link) []*otlptrace.Span_Link {
+	var newDest []*otlptrace.Span_Link
 	if cap(dest) < len(src) {
-		dest = make([]*otlptrace.Span_Link, len(src))
-		data := make([]otlptrace.Span_Link, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlptrace.Span_Link, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.Span_Link{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.Span_Link{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigSpanLink(dest[i], src[i])
+		copyOrigSpanLink(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/ptrace/generated_spanlinkslice_test.go b/pdata/ptrace/generated_spanlinkslice_test.go
index 99553d95815e..576fcc648826 100644
--- a/pdata/ptrace/generated_spanlinkslice_test.go
+++ b/pdata/ptrace/generated_spanlinkslice_test.go
@@ -51,16 +51,25 @@ func TestSpanLinkSliceReadOnly(t *testing.T) {
 
 func TestSpanLinkSlice_CopyTo(t *testing.T) {
 	dest := NewSpanLinkSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewSpanLinkSlice().CopyTo(dest)
 	assert.Equal(t, NewSpanLinkSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestSpanLinkSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestSpanLinkSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSpanLinkSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestSpanLinkSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestSpanLinkSlice(), dest)
+}
+
+func TestSpanLinkSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSpanLinkSlice()
+	src := generateTestSpanLinkSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSpanLinkSlice(), dest)
 }
 
diff --git a/pdata/ptrace/generated_spanslice.go b/pdata/ptrace/generated_spanslice.go
index d0ce15fadf78..eaa9682b5a84 100644
--- a/pdata/ptrace/generated_spanslice.go
+++ b/pdata/ptrace/generated_spanslice.go
@@ -180,16 +180,30 @@ func (ms SpanSlice) unmarshalJSONIter(iter *json.Iterator) {
 }
 
 func copyOrigSpanSlice(dest, src []*otlptrace.Span) []*otlptrace.Span {
+	var newDest []*otlptrace.Span
 	if cap(dest) < len(src) {
-		dest = make([]*otlptrace.Span, len(src))
-		data := make([]otlptrace.Span, len(src))
-		for i := range src {
-			dest[i] = &data[i]
+		newDest = make([]*otlptrace.Span, len(src))
+		// Copy old pointers to re-use.
+		copy(newDest, dest)
+		// Add new pointers for missing elements from len(dest) to len(srt).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.Span{}
+		}
+	} else {
+		newDest = dest[:len(src)]
+		// Cleanup the rest of the elements so GC can free the memory.
+		// This can happen when len(src) < len(dest) < cap(dest).
+		for i := len(src); i < len(dest); i++ {
+			dest[i] = nil
+		}
+		// Add new pointers for missing elements.
+		// This can happen when len(dest) < len(src) < cap(dest).
+		for i := len(dest); i < len(src); i++ {
+			newDest[i] = &otlptrace.Span{}
 		}
 	}
-	dest = dest[:len(src)]
 	for i := range src {
-		copyOrigSpan(dest[i], src[i])
+		copyOrigSpan(newDest[i], src[i])
 	}
-	return dest
+	return newDest
 }
diff --git a/pdata/ptrace/generated_spanslice_test.go b/pdata/ptrace/generated_spanslice_test.go
index 3b5f7c4c7997..018e7313bbff 100644
--- a/pdata/ptrace/generated_spanslice_test.go
+++ b/pdata/ptrace/generated_spanslice_test.go
@@ -51,16 +51,25 @@ func TestSpanSliceReadOnly(t *testing.T) {
 
 func TestSpanSlice_CopyTo(t *testing.T) {
 	dest := NewSpanSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewSpanSlice().CopyTo(dest)
 	assert.Equal(t, NewSpanSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestSpanSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestSpanSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSpanSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestSpanSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestSpanSlice(), dest)
+}
+
+func TestSpanSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewSpanSlice()
+	src := generateTestSpanSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestSpanSlice(), dest)
 }
 
diff --git a/pdata/xpdata/entity/generated_entityrefslice_test.go b/pdata/xpdata/entity/generated_entityrefslice_test.go
index a9673e85e190..735a1a14e021 100644
--- a/pdata/xpdata/entity/generated_entityrefslice_test.go
+++ b/pdata/xpdata/entity/generated_entityrefslice_test.go
@@ -51,16 +51,25 @@ func TestEntityRefSliceReadOnly(t *testing.T) {
 
 func TestEntityRefSlice_CopyTo(t *testing.T) {
 	dest := NewEntityRefSlice()
-	// Test CopyTo to empty
+	// Test CopyTo empty
 	NewEntityRefSlice().CopyTo(dest)
 	assert.Equal(t, NewEntityRefSlice(), dest)
 
-	// Test CopyTo larger slice
-	generateTestEntityRefSlice().CopyTo(dest)
+	// Test CopyTo larger slice and EnsureCapacity
+	src := generateTestEntityRefSlice()
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestEntityRefSlice(), dest)
 
 	// Test CopyTo same size slice
-	generateTestEntityRefSlice().CopyTo(dest)
+	src.CopyTo(dest)
+	assert.Equal(t, generateTestEntityRefSlice(), dest)
+}
+
+func TestEntityRefSlice_CopyToAndEnsureCapacity(t *testing.T) {
+	dest := NewEntityRefSlice()
+	src := generateTestEntityRefSlice()
+	dest.EnsureCapacity(src.Len())
+	src.CopyTo(dest)
 	assert.Equal(t, generateTestEntityRefSlice(), dest)
 }