chore(collector): upgrade semconv to 1.40.0

collector/processor/coldstartprocessor/processor.go

@@ -23,7 +23,7 @@ import (
 	"go.opentelemetry.io/collector/processor"
 	"go.opentelemetry.io/collector/processor/processorhelper"
 	semconvlegacy "go.opentelemetry.io/otel/semconv/v1.18.0"
-	semconv "go.opentelemetry.io/otel/semconv/v1.25.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 	"go.uber.org/zap"
 )
 

collector/processor/coldstartprocessor/processor_test.go

@@ -33,8 +33,7 @@ import (
 	"go.opentelemetry.io/collector/pdata/ptrace"
 	"go.opentelemetry.io/collector/processor/processorhelper"
 	"go.opentelemetry.io/collector/processor/processortest"
-	semconvlegacy "go.opentelemetry.io/otel/semconv/v1.18.0"
-	semconv "go.opentelemetry.io/otel/semconv/v1.25.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 	"go.uber.org/multierr"
 )
 
@@ -78,7 +77,7 @@ func TestProcessor(t *testing.T) {
 			}(),
 		},
 		{
-			desc: "faas.execution and faas.coldstart with coldstart is first",
+			desc: "faas.invocation_id and faas.coldstart with coldstart is first",
 			input: func() ptrace.Traces {
 				td := ptrace.NewTraces()
 				span := td.ResourceSpans().AppendEmpty().ScopeSpans().AppendEmpty().Spans().AppendEmpty()
@@ -101,7 +100,7 @@ func TestProcessor(t *testing.T) {
 			reported: true,
 		},
 		{
-			desc: "faas.execution and faas.coldstart with execution is first",
+			desc: "faas.invocation_id and faas.coldstart with execution is first",
 			input: func() ptrace.Traces {
 				td := ptrace.NewTraces()
 				addExecutionSpan(td, executionTraceID)
@@ -268,12 +267,12 @@ func addExecutionSpan(td ptrace.Traces, id pcommon.TraceID) {
 	ss.Scope().SetName("app/execution")
 	span := ss.Spans().AppendEmpty()
 	span.SetTraceID(id)
-	span.Attributes().PutStr(string(semconvlegacy.FaaSExecutionKey), "af9d5aa4-a685-4c5f-a22b-444f80b3cc28")
+	span.Attributes().PutStr(string(semconv.FaaSInvocationIDKey), "af9d5aa4-a685-4c5f-a22b-444f80b3cc28")
 }
 
 func executionSpan(span ptrace.Span, id pcommon.TraceID) {
 	span.SetTraceID(id)
-	span.Attributes().PutStr(string(semconvlegacy.FaaSExecutionKey), "af9d5aa4-a685-4c5f-a22b-444f80b3cc28")
+	span.Attributes().PutStr(string(semconv.FaaSInvocationIDKey), "af9d5aa4-a685-4c5f-a22b-444f80b3cc28")
 }
 
 func initializationSpan(span ptrace.Span, id pcommon.TraceID) {

collector/receiver/telemetryapireceiver/metric_builder.go

@@ -20,7 +20,7 @@ import (
 	"github.com/open-telemetry/opentelemetry-collector-contrib/pkg/pdatautil"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/pmetric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.25.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/faasconv"
 )
 
 const MiB = float64(1 << 20)
@@ -284,76 +284,83 @@ func (c *CounterMetricBuilder) AppendDataPoints(scopeMetrics pmetric.ScopeMetric
 }
 
 func NewFaaSInvokeDurationMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *HistogramMetricBuilder {
+	m := faasconv.InvokeDuration{}
 	return NewHistogramMetricBuilder(
-		semconv.FaaSInvokeDurationName,
-		semconv.FaaSInvokeDurationDescription,
-		semconv.FaaSInvokeDurationUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		DurationHistogramBounds,
 		startTime,
 		temporality,
 	)
 }
 
 func NewFaaSInitDurationMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *HistogramMetricBuilder {
+	m := faasconv.InitDuration{}
 	return NewHistogramMetricBuilder(
-		semconv.FaaSInitDurationName,
-		semconv.FaaSInitDurationDescription,
-		semconv.FaaSInitDurationUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		DurationHistogramBounds,
 		startTime,
 		temporality,
 	)
 }
 
 func NewFaaSMemUsageMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *HistogramMetricBuilder {
+	m := faasconv.MemUsage{}
 	return NewHistogramMetricBuilder(
-		semconv.FaaSMemUsageName,
-		semconv.FaaSMemUsageDescription,
-		semconv.FaaSMemUsageUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		MemUsageHistogramBounds,
 		startTime,
 		temporality,
 	)
 }
 
 func NewFaaSColdstartsMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *CounterMetricBuilder {
+	m := faasconv.Coldstarts{}
 	return NewCounterMetricBuilder(
-		semconv.FaaSColdstartsName,
-		semconv.FaaSColdstartsDescription,
-		semconv.FaaSColdstartsUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		true,
 		startTime,
 		temporality,
 	)
 }
 
 func NewFaaSErrorsMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *CounterMetricBuilder {
+	m := faasconv.Errors{}
 	return NewCounterMetricBuilder(
-		semconv.FaaSErrorsName,
-		semconv.FaaSErrorsDescription,
-		semconv.FaaSErrorsUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		true,
 		startTime,
 		temporality,
 	)
 }
 
 func NewFaaSInvocationsMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *CounterMetricBuilder {
+	m := faasconv.Invocations{}
 	return NewCounterMetricBuilder(
-		semconv.FaaSInvocationsName,
-		semconv.FaaSInvocationsDescription,
-		semconv.FaaSInvocationsUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		true,
 		startTime,
 		temporality,
 	)
 }
 
 func NewFaaSTimeoutsMetricBuilder(startTime pcommon.Timestamp, temporality pmetric.AggregationTemporality) *CounterMetricBuilder {
+	m := faasconv.Timeouts{}
 	return NewCounterMetricBuilder(
-		semconv.FaaSTimeoutsName,
-		semconv.FaaSTimeoutsDescription,
-		semconv.FaaSTimeoutsUnit,
+		m.Name(),
+		m.Description(),
+		m.Unit(),
 		true,
 		startTime,
 		temporality,

collector/receiver/telemetryapireceiver/metric_builder_test.go

@@ -22,7 +22,7 @@ import (
 	"github.com/stretchr/testify/require"
 	"go.opentelemetry.io/collector/pdata/pcommon"
 	"go.opentelemetry.io/collector/pdata/pmetric"
-	semconv "go.opentelemetry.io/otel/semconv/v1.25.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/faasconv"
 )
 
 func TestHistogramMetricBuilder_AppendDataPoint(t *testing.T) {
@@ -202,69 +202,76 @@ func TestFaaSMetricBuilderFactories(t *testing.T) {
 
 	t.Run("NewFasSInvokeDurationMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSInvokeDurationMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSInvokeDurationName, builder.name)
-		assert.Equal(t, semconv.FaaSInvokeDurationDescription, builder.description)
-		assert.Equal(t, semconv.FaaSInvokeDurationUnit, builder.unit)
+		m := faasconv.InvokeDuration{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.Equal(t, DurationHistogramBounds, builder.bounds)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
 	})
 
 	t.Run("NewFasSInitDurationMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSInitDurationMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSInitDurationName, builder.name)
-		assert.Equal(t, semconv.FaaSInitDurationDescription, builder.description)
-		assert.Equal(t, semconv.FaaSInitDurationUnit, builder.unit)
+		m := faasconv.InitDuration{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.Equal(t, DurationHistogramBounds, builder.bounds)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
 	})
 
 	t.Run("NewFaaSMemUsageMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSMemUsageMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSMemUsageName, builder.name)
-		assert.Equal(t, semconv.FaaSMemUsageDescription, builder.description)
-		assert.Equal(t, semconv.FaaSMemUsageUnit, builder.unit)
+		m := faasconv.MemUsage{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.Equal(t, MemUsageHistogramBounds, builder.bounds)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
 	})
 
 	t.Run("NewFaaSColdstartsMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSColdstartsMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSColdstartsName, builder.name)
-		assert.Equal(t, semconv.FaaSColdstartsDescription, builder.description)
-		assert.Equal(t, semconv.FaaSColdstartsUnit, builder.unit)
+		m := faasconv.Coldstarts{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.True(t, builder.isMonotonic)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
 	})
 
 	t.Run("NewFaaSErrorsMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSErrorsMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSErrorsName, builder.name)
-		assert.Equal(t, semconv.FaaSErrorsDescription, builder.description)
-		assert.Equal(t, semconv.FaaSErrorsUnit, builder.unit)
+		m := faasconv.Errors{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.True(t, builder.isMonotonic)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
 	})
 
 	t.Run("NewFaaSInvocationsMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSInvocationsMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSInvocationsName, builder.name)
-		assert.Equal(t, semconv.FaaSInvocationsDescription, builder.description)
-		assert.Equal(t, semconv.FaaSInvocationsUnit, builder.unit)
+		m := faasconv.Invocations{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.True(t, builder.isMonotonic)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
 	})
 
 	t.Run("NewFaaSTimeoutsMetricBuilder", func(t *testing.T) {
 		builder := NewFaaSTimeoutsMetricBuilder(startTime, pmetric.AggregationTemporalityCumulative)
-		assert.Equal(t, semconv.FaaSTimeoutsName, builder.name)
-		assert.Equal(t, semconv.FaaSTimeoutsDescription, builder.description)
-		assert.Equal(t, semconv.FaaSTimeoutsUnit, builder.unit)
+		m := faasconv.Timeouts{}
+		assert.Equal(t, m.Name(), builder.name)
+		assert.Equal(t, m.Description(), builder.description)
+		assert.Equal(t, m.Unit(), builder.unit)
 		assert.True(t, builder.isMonotonic)
 		assert.Equal(t, pmetric.AggregationTemporalityCumulative, builder.temporality)
 		assert.Equal(t, startTime, builder.startTime)
@@ -284,13 +291,13 @@ func TestNewFaaSMetricBuilders(t *testing.T) {
 	require.NotNil(t, builders.invocationsMetric)
 	require.NotNil(t, builders.timeoutsMetric)
 
-	assert.Equal(t, semconv.FaaSInvokeDurationName, builders.invokeDurationMetric.name)
-	assert.Equal(t, semconv.FaaSInitDurationName, builders.initDurationMetric.name)
-	assert.Equal(t, semconv.FaaSMemUsageName, builders.memUsageMetric.name)
-	assert.Equal(t, semconv.FaaSColdstartsName, builders.coldstartsMetric.name)
-	assert.Equal(t, semconv.FaaSErrorsName, builders.errorsMetric.name)
-	assert.Equal(t, semconv.FaaSInvocationsName, builders.invocationsMetric.name)
-	assert.Equal(t, semconv.FaaSTimeoutsName, builders.timeoutsMetric.name)
+	assert.Equal(t, faasconv.InvokeDuration{}.Name(), builders.invokeDurationMetric.name)
+	assert.Equal(t, faasconv.InitDuration{}.Name(), builders.initDurationMetric.name)
+	assert.Equal(t, faasconv.MemUsage{}.Name(), builders.memUsageMetric.name)
+	assert.Equal(t, faasconv.Coldstarts{}.Name(), builders.coldstartsMetric.name)
+	assert.Equal(t, faasconv.Errors{}.Name(), builders.errorsMetric.name)
+	assert.Equal(t, faasconv.Invocations{}.Name(), builders.invocationsMetric.name)
+	assert.Equal(t, faasconv.Timeouts{}.Name(), builders.timeoutsMetric.name)
 }
 
 func TestDefaultHistogramBounds(t *testing.T) {

collector/receiver/telemetryapireceiver/receiver.go

@@ -39,7 +39,7 @@ import (
 	"go.opentelemetry.io/collector/pdata/pmetric"
 	"go.opentelemetry.io/collector/pdata/ptrace"
 	"go.opentelemetry.io/collector/receiver"
-	semconv "go.opentelemetry.io/otel/semconv/v1.25.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
 	"go.uber.org/zap"
 )
 

collector/receiver/telemetryapireceiver/receiver_test.go

@@ -28,7 +28,8 @@ import (
 	"go.opentelemetry.io/collector/pdata/pmetric"
 	"go.opentelemetry.io/collector/pdata/ptrace"
 	"go.opentelemetry.io/collector/receiver/receivertest"
-	semconv "go.opentelemetry.io/otel/semconv/v1.25.0"
+	semconv "go.opentelemetry.io/otel/semconv/v1.40.0"
+	"go.opentelemetry.io/otel/semconv/v1.40.0/faasconv"
 )
 
 func TestListenOnAddress(t *testing.T) {
@@ -148,13 +149,13 @@ func TestRecordMetrics(t *testing.T) {
 	sm := rm.ScopeMetrics().At(0)
 	for i := 0; i < sm.Metrics().Len(); i++ {
 		m := sm.Metrics().At(i)
-		if m.Name() == semconv.FaaSColdstartsName {
+		if m.Name() == (faasconv.Coldstarts{}).Name() {
 			foundColdstart = true
 		}
-		if m.Name() == semconv.FaaSInvocationsName {
+		if m.Name() == (faasconv.Invocations{}).Name() {
 			foundInvocation = true
 		}
-		if m.Name() == semconv.FaaSInvokeDurationName {
+		if m.Name() == (faasconv.InvokeDuration{}).Name() {
 			foundDuration = true
 		}
 	}