pass scope resource and logs to encode span event too

Author: dmathieu

exporter/elasticsearchexporter/exporter.go

@@ -360,19 +360,18 @@ func (e *elasticsearchExporter) pushTraceData(
 		scopeSpans := il.ScopeSpans()
 		for j := 0; j < scopeSpans.Len(); j++ {
 			scopeSpan := scopeSpans.At(j)
-			scope := scopeSpan.Scope()
 			spans := scopeSpan.Spans()
 			for k := 0; k < spans.Len(); k++ {
 				span := spans.At(k)
-				if err := e.pushTraceRecord(ctx, resource, il.SchemaUrl(), span, scope, scopeSpan.SchemaUrl(), session); err != nil {
+				if err := e.pushTraceRecord(ctx, il, scopeSpan, span, session); err != nil {
 					if cerr := ctx.Err(); cerr != nil {
 						return cerr
 					}
 					errs = append(errs, err)
 				}
 				for ii := 0; ii < span.Events().Len(); ii++ {
 					spanEvent := span.Events().At(ii)
-					if err := e.pushSpanEvent(ctx, resource, il.SchemaUrl(), span, spanEvent, scope, scopeSpan.SchemaUrl(), session); err != nil {
+					if err := e.pushSpanEvent(ctx, resource, il.SchemaUrl(), span, spanEvent, scopeSpan.Scope(), scopeSpan.SchemaUrl(), session); err != nil {
 						errs = append(errs, err)
 					}
 				}
@@ -391,16 +390,21 @@ func (e *elasticsearchExporter) pushTraceData(
 
 func (e *elasticsearchExporter) pushTraceRecord(
 	ctx context.Context,
-	resource pcommon.Resource,
-	resourceSchemaURL string,
+	resourceSpans ptrace.ResourceSpans,
+	scopeSpans ptrace.ScopeSpans,
 	span ptrace.Span,
-	scope pcommon.InstrumentationScope,
-	scopeSchemaURL string,
 	bulkIndexerSession bulkIndexerSession,
 ) error {
 	fIndex := e.index
 	if e.dynamicIndex {
-		fIndex = routeSpan(span.Attributes(), scope.Attributes(), resource.Attributes(), fIndex, e.otel, span.Name())
+		fIndex = routeSpan(
+			span.Attributes(),
+			scopeSpans.Scope().Attributes(),
+			resourceSpans.Resource().Attributes(),
+			fIndex,
+			e.otel,
+			span.Name(),
+		)
 	}
 
 	if e.logstashFormat.Enabled {
@@ -411,7 +415,7 @@ func (e *elasticsearchExporter) pushTraceRecord(
 		fIndex = formattedIndex
 	}
 
-	document, err := e.model.encodeSpan(resource, resourceSchemaURL, span, scope, scopeSchemaURL)
+	document, err := e.model.encodeSpan(resourceSpans, scopeSpans, span)
 	if err != nil {
 		return fmt.Errorf("failed to encode trace record: %w", err)
 	}

exporter/elasticsearchexporter/model.go

@@ -79,7 +79,7 @@ var ErrInvalidTypeForBodyMapMode = errors.New("invalid log record body type for
 
 type mappingModel interface {
 	encodeLog(pcommon.Resource, string, plog.LogRecord, plog.ScopeLogs) ([]byte, error)
-	encodeSpan(pcommon.Resource, string, ptrace.Span, pcommon.InstrumentationScope, string) ([]byte, error)
+	encodeSpan(ptrace.ResourceSpans, ptrace.ScopeSpans, ptrace.Span) ([]byte, error)
 	encodeSpanEvent(resource pcommon.Resource, resourceSchemaURL string, span ptrace.Span, spanEvent ptrace.SpanEvent, scope pcommon.InstrumentationScope, scopeSchemaURL string) *objmodel.Document
 	upsertMetricDataPointValue(map[uint32]objmodel.Document, pcommon.Resource, string, pcommon.InstrumentationScope, string, pmetric.Metric, dataPoint) error
 	encodeDocument(objmodel.Document) ([]byte, error)
@@ -638,13 +638,13 @@ func (m *encodeModel) encodeAttributesOTelMode(document *objmodel.Document, attr
 	document.AddAttributes("attributes", attrsCopy)
 }
 
-func (m *encodeModel) encodeSpan(resource pcommon.Resource, resourceSchemaURL string, span ptrace.Span, scope pcommon.InstrumentationScope, scopeSchemaURL string) ([]byte, error) {
+func (m *encodeModel) encodeSpan(resourceSpans ptrace.ResourceSpans, scopeSpans ptrace.ScopeSpans, span ptrace.Span) ([]byte, error) {
 	var document objmodel.Document
 	switch m.mode {
 	case mapping.ModeOTel:
-		document = m.encodeSpanOTelMode(resource, resourceSchemaURL, span, scope, scopeSchemaURL)
+		document = m.encodeSpanOTelMode(resourceSpans.Resource(), resourceSpans.SchemaUrl(), span, scopeSpans.Scope(), scopeSpans.SchemaUrl())
 	default:
-		document = m.encodeSpanDefaultMode(resource, span, scope)
+		document = m.encodeSpanDefaultMode(resourceSpans.Resource(), span, scopeSpans.Scope())
 	}
 	// For OTel mode, prefix conflicts are not a problem as otel-data has subobjects: false
 	document.Dedup(m.mode != mapping.ModeOTel)

exporter/elasticsearchexporter/model_test.go

@@ -57,7 +57,11 @@ var (
 func TestEncodeSpan(t *testing.T) {
 	model := &encodeModel{dedot: false}
 	td := mockResourceSpans()
-	spanByte, err := model.encodeSpan(td.ResourceSpans().At(0).Resource(), "", td.ResourceSpans().At(0).ScopeSpans().At(0).Spans().At(0), td.ResourceSpans().At(0).ScopeSpans().At(0).Scope(), "")
+	spanByte, err := model.encodeSpan(
+		td.ResourceSpans().At(0),
+		td.ResourceSpans().At(0).ScopeSpans().At(0),
+		td.ResourceSpans().At(0).ScopeSpans().At(0).Spans().At(0),
+	)
 	assert.NoError(t, err)
 	assert.Equal(t, expectedSpanBody, string(spanByte))
 }