[chore]: enable len rule from testifylint

.golangci.yml

@@ -141,7 +141,6 @@ linters-settings:
       - expected-actual
       - float-compare
       - go-require
-      - len
       - negative-positive
       - nil-compare
       - require-error

cmd/telemetrygen/internal/traces/worker_test.go

@@ -262,7 +262,7 @@ func TestSpansWithNoAttrs(t *testing.T) {
 	assert.Len(t, syncer.spans, 4) // each trace has two spans
 	for _, span := range syncer.spans {
 		attributes := span.Attributes()
-		assert.Equal(t, 2, len(attributes), "it shouldn't have more than 2 fixed attributes")
+		assert.Len(t, attributes, 2, "it shouldn't have more than 2 fixed attributes")
 	}
 }
 
@@ -284,7 +284,7 @@ func TestSpansWithOneAttrs(t *testing.T) {
 	assert.Len(t, syncer.spans, 4) // each trace has two spans
 	for _, span := range syncer.spans {
 		attributes := span.Attributes()
-		assert.Equal(t, 3, len(attributes), "it should have more than 3 attributes")
+		assert.Len(t, attributes, 3, "it should have more than 3 attributes")
 	}
 }
 
@@ -306,7 +306,7 @@ func TestSpansWithMultipleAttrs(t *testing.T) {
 	assert.Len(t, syncer.spans, 4) // each trace has two spans
 	for _, span := range syncer.spans {
 		attributes := span.Attributes()
-		assert.Equal(t, 4, len(attributes), "it should have more than 4 attributes")
+		assert.Len(t, attributes, 4, "it should have more than 4 attributes")
 	}
 }
 

connector/countconnector/connector_test.go

@@ -265,7 +265,7 @@ func TestTracesToMetrics(t *testing.T) {
 			assert.NoError(t, conn.ConsumeTraces(context.Background(), testSpans))
 
 			allMetrics := sink.AllMetrics()
-			assert.Equal(t, 1, len(allMetrics))
+			assert.Len(t, allMetrics, 1)
 
 			// golden.WriteMetrics(t, filepath.Join("testdata", "traces", tc.name+".yaml"), allMetrics[0])
 			expected, err := golden.ReadMetrics(filepath.Join("testdata", "traces", tc.name+".yaml"))
@@ -507,7 +507,7 @@ func TestMetricsToMetrics(t *testing.T) {
 			assert.NoError(t, conn.ConsumeMetrics(context.Background(), testMetrics))
 
 			allMetrics := sink.AllMetrics()
-			assert.Equal(t, 1, len(allMetrics))
+			assert.Len(t, allMetrics, 1)
 
 			// golden.WriteMetrics(t, filepath.Join("testdata", "metrics", tc.name+".yaml"), allMetrics[0])
 			expected, err := golden.ReadMetrics(filepath.Join("testdata", "metrics", tc.name+".yaml"))
@@ -679,7 +679,7 @@ func TestLogsToMetrics(t *testing.T) {
 			assert.NoError(t, conn.ConsumeLogs(context.Background(), testLogs))
 
 			allMetrics := sink.AllMetrics()
-			assert.Equal(t, 1, len(allMetrics))
+			assert.Len(t, allMetrics, 1)
 
 			// golden.WriteMetrics(t, filepath.Join("testdata", "logs", tc.name+".yaml"), allMetrics[0])
 			expected, err := golden.ReadMetrics(filepath.Join("testdata", "logs", tc.name+".yaml"))

connector/datadogconnector/connector_native_test.go

@@ -104,7 +104,7 @@ func TestContainerTagsNative(t *testing.T) {
 
 	// check if the container tags are added to the metrics
 	metrics := metricsSink.AllMetrics()
-	assert.Equal(t, 1, len(metrics))
+	assert.Len(t, metrics, 1)
 
 	ch := make(chan []byte, 100)
 	tr := newTranslatorWithStatsChannel(t, zap.NewNop(), ch)
@@ -117,7 +117,7 @@ func TestContainerTagsNative(t *testing.T) {
 	require.NoError(t, err)
 
 	tags := sp.Stats[0].Tags
-	assert.Equal(t, 3, len(tags))
+	assert.Len(t, tags, 3)
 	assert.ElementsMatch(t, []string{"region:my-region", "zone:my-zone", "az:my-az"}, tags)
 }
 
@@ -187,7 +187,7 @@ func TestMeasuredAndClientKindNative(t *testing.T) {
 	}
 
 	metrics := metricsSink.AllMetrics()
-	require.Equal(t, 1, len(metrics))
+	require.Len(t, metrics, 1)
 
 	ch := make(chan []byte, 100)
 	tr := newTranslatorWithStatsChannel(t, zap.NewNop(), ch)

connector/datadogconnector/connector_test.go

@@ -158,7 +158,7 @@ func TestContainerTags(t *testing.T) {
 	err = connector.ConsumeTraces(context.Background(), trace2)
 	assert.NoError(t, err)
 	// check if the container tags are added to the cache
-	assert.Equal(t, 1, len(connector.containerTagCache.Items()))
+	assert.Len(t, connector.containerTagCache.Items(), 1)
 	count := 0
 	connector.containerTagCache.Items()["my-container-id"].Object.(*sync.Map).Range(func(_, _ any) bool {
 		count++
@@ -175,7 +175,7 @@ func TestContainerTags(t *testing.T) {
 
 	// check if the container tags are added to the metrics
 	metrics := metricsSink.AllMetrics()
-	assert.Equal(t, 1, len(metrics))
+	assert.Len(t, metrics, 1)
 
 	ch := make(chan []byte, 100)
 	tr := newTranslatorWithStatsChannel(t, zap.NewNop(), ch)
@@ -188,7 +188,7 @@ func TestContainerTags(t *testing.T) {
 	require.NoError(t, err)
 
 	tags := sp.Stats[0].Tags
-	assert.Equal(t, 3, len(tags))
+	assert.Len(t, tags, 3)
 	assert.ElementsMatch(t, []string{"region:my-region", "zone:my-zone", "az:my-az"}, tags)
 }
 

connector/roundrobinconnector/connector_test.go

@@ -50,17 +50,17 @@ func TestLogsRoundRobin(t *testing.T) {
 	assert.NoError(t, logs.ConsumeLogs(ctx, plog.NewLogs()))
 	assert.NoError(t, logs.ConsumeLogs(ctx, plog.NewLogs()))
 
-	assert.Equal(t, 1, len(sink1.AllLogs()))
-	assert.Equal(t, 1, len(sink2.AllLogs()))
-	assert.Equal(t, 1, len(sink3.AllLogs()))
+	assert.Len(t, sink1.AllLogs(), 1)
+	assert.Len(t, sink2.AllLogs(), 1)
+	assert.Len(t, sink3.AllLogs(), 1)
 
 	assert.NoError(t, logs.ConsumeLogs(ctx, plog.NewLogs()))
 	assert.NoError(t, logs.ConsumeLogs(ctx, plog.NewLogs()))
 	assert.NoError(t, logs.ConsumeLogs(ctx, plog.NewLogs()))
 
-	assert.Equal(t, 2, len(sink1.AllLogs()))
-	assert.Equal(t, 2, len(sink2.AllLogs()))
-	assert.Equal(t, 2, len(sink3.AllLogs()))
+	assert.Len(t, sink1.AllLogs(), 2)
+	assert.Len(t, sink2.AllLogs(), 2)
+	assert.Len(t, sink3.AllLogs(), 2)
 
 	assert.NoError(t, logs.Shutdown(ctx))
 }
@@ -87,17 +87,17 @@ func TestMetricsRoundRobin(t *testing.T) {
 	assert.NoError(t, metrics.ConsumeMetrics(ctx, pmetric.NewMetrics()))
 	assert.NoError(t, metrics.ConsumeMetrics(ctx, pmetric.NewMetrics()))
 
-	assert.Equal(t, 1, len(sink1.AllMetrics()))
-	assert.Equal(t, 1, len(sink2.AllMetrics()))
-	assert.Equal(t, 1, len(sink3.AllMetrics()))
+	assert.Len(t, sink1.AllMetrics(), 1)
+	assert.Len(t, sink2.AllMetrics(), 1)
+	assert.Len(t, sink3.AllMetrics(), 1)
 
 	assert.NoError(t, metrics.ConsumeMetrics(ctx, pmetric.NewMetrics()))
 	assert.NoError(t, metrics.ConsumeMetrics(ctx, pmetric.NewMetrics()))
 	assert.NoError(t, metrics.ConsumeMetrics(ctx, pmetric.NewMetrics()))
 
-	assert.Equal(t, 2, len(sink1.AllMetrics()))
-	assert.Equal(t, 2, len(sink2.AllMetrics()))
-	assert.Equal(t, 2, len(sink3.AllMetrics()))
+	assert.Len(t, sink1.AllMetrics(), 2)
+	assert.Len(t, sink2.AllMetrics(), 2)
+	assert.Len(t, sink3.AllMetrics(), 2)
 
 	assert.NoError(t, metrics.Shutdown(ctx))
 }
@@ -124,17 +124,17 @@ func TestTracesRoundRobin(t *testing.T) {
 	assert.NoError(t, traces.ConsumeTraces(ctx, ptrace.NewTraces()))
 	assert.NoError(t, traces.ConsumeTraces(ctx, ptrace.NewTraces()))
 
-	assert.Equal(t, 1, len(sink1.AllTraces()))
-	assert.Equal(t, 1, len(sink2.AllTraces()))
-	assert.Equal(t, 1, len(sink3.AllTraces()))
+	assert.Len(t, sink1.AllTraces(), 1)
+	assert.Len(t, sink2.AllTraces(), 1)
+	assert.Len(t, sink3.AllTraces(), 1)
 
 	assert.NoError(t, traces.ConsumeTraces(ctx, ptrace.NewTraces()))
 	assert.NoError(t, traces.ConsumeTraces(ctx, ptrace.NewTraces()))
 	assert.NoError(t, traces.ConsumeTraces(ctx, ptrace.NewTraces()))
 
-	assert.Equal(t, 2, len(sink1.AllTraces()))
-	assert.Equal(t, 2, len(sink2.AllTraces()))
-	assert.Equal(t, 2, len(sink3.AllTraces()))
+	assert.Len(t, sink1.AllTraces(), 2)
+	assert.Len(t, sink2.AllTraces(), 2)
+	assert.Len(t, sink3.AllTraces(), 2)
 
 	assert.NoError(t, traces.Shutdown(ctx))
 }

connector/servicegraphconnector/connector_test.go

@@ -480,7 +480,7 @@ func TestStaleSeriesCleanup(t *testing.T) {
 		p.keyToMetric[key] = metric
 	}
 	p.cleanCache()
-	assert.Equal(t, 0, len(p.keyToMetric))
+	assert.Len(t, p.keyToMetric, 0)
 
 	// ConsumeTraces with a trace with different attribute value
 	td = buildSampleTrace(t, "second")
@@ -526,8 +526,8 @@ func TestMapsAreConsistentDuringCleanup(t *testing.T) {
 	go p.cleanCache()
 
 	// Since everything is locked, nothing has happened, so both should still have length 1
-	assert.Equal(t, 1, len(p.reqTotal))
-	assert.Equal(t, 1, len(p.keyToMetric))
+	assert.Len(t, p.reqTotal, 1)
+	assert.Len(t, p.keyToMetric, 1)
 
 	// Now we pretend that we have stopped collecting metrics, by unlocking seriesMutex
 	p.seriesMutex.Unlock()
@@ -540,8 +540,8 @@ func TestMapsAreConsistentDuringCleanup(t *testing.T) {
 	// for dimensions from that series. It's important that it happens this way around,
 	// instead of deleting it from `keyToMetric`, otherwise the metrics collector will try
 	// and fail to find dimensions for a series that is about to be removed.
-	assert.Equal(t, 0, len(p.reqTotal))
-	assert.Equal(t, 1, len(p.keyToMetric))
+	assert.Len(t, p.reqTotal, 0)
+	assert.Len(t, p.keyToMetric, 1)
 
 	p.metricMutex.RUnlock()
 	p.seriesMutex.Unlock()
@@ -575,7 +575,7 @@ func TestValidateOwnTelemetry(t *testing.T) {
 		p.keyToMetric[key] = metric
 	}
 	p.cleanCache()
-	assert.Equal(t, 0, len(p.keyToMetric))
+	assert.Len(t, p.keyToMetric, 0)
 
 	// ConsumeTraces with a trace with different attribute value
 	td = buildSampleTrace(t, "second")

exporter/alertmanagerexporter/alertmanager_exporter_test.go

@@ -101,7 +101,7 @@ func TestAlertManagerExporterExtractEvents(t *testing.T) {
 
 			// test - events
 			got := am.extractEvents(traces)
-			assert.Equal(t, tt.events, len(got))
+			assert.Len(t, got, tt.events)
 		})
 	}
 }
@@ -133,7 +133,7 @@ func TestAlertManagerExporterEventNameAttributes(t *testing.T) {
 	got := am.extractEvents(traces)
 
 	// test - result length
-	assert.Equal(t, 1, len(got))
+	assert.Len(t, got, 1)
 
 	// test - count of attributes
 	assert.Equal(t, 3, got[0].spanEvent.Attributes().Len())

exporter/alibabacloudlogserviceexporter/logsdata_to_logservice_test.go

@@ -75,7 +75,7 @@ func TestLogsDataToLogService(t *testing.T) {
 	totalLogCount := 10
 	validLogCount := totalLogCount - 1
 	gotLogs := logDataToLogService(createLogData(10))
-	assert.Equal(t, len(gotLogs), 9)
+	assert.Len(t, gotLogs, 9)
 
 	gotLogPairs := make([][]logKeyValuePair, 0, len(gotLogs))
 

exporter/alibabacloudlogserviceexporter/tracedata_to_logservice_test.go

@@ -30,7 +30,7 @@ func (kv logKeyValuePairs) Less(i, j int) bool { return kv[i].Key < kv[j].Key }
 
 func TestTraceDataToLogService(t *testing.T) {
 	gotLogs := traceDataToLogServiceData(constructSpanData())
-	assert.Equal(t, len(gotLogs), 2)
+	assert.Len(t, gotLogs, 2)
 
 	gotLogPairs := make([][]logKeyValuePair, 0, len(gotLogs))
 

exporter/awsemfexporter/config_test.go

@@ -140,7 +140,7 @@ func TestConfigValidate(t *testing.T) {
 	}
 	assert.NoError(t, component.ValidateConfig(cfg))
 
-	assert.Equal(t, 2, len(cfg.MetricDescriptors))
+	assert.Len(t, cfg.MetricDescriptors, 2)
 	assert.Equal(t, []MetricDescriptor{
 		{Unit: "Count", MetricName: "apiserver_total", Overwrite: true},
 		{Unit: "Megabytes", MetricName: "memory_usage"},

exporter/awsemfexporter/emf_exporter_test.go

@@ -370,9 +370,9 @@ func TestNewExporterWithMetricDeclarations(t *testing.T) {
 	assert.NoError(t, err)
 
 	// Invalid metric declaration should be filtered out
-	assert.Equal(t, 3, len(exp.config.MetricDeclarations))
+	assert.Len(t, exp.config.MetricDeclarations, 3)
 	// Invalid dimensions (> 10 dims) should be filtered out
-	assert.Equal(t, 1, len(exp.config.MetricDeclarations[2].Dimensions))
+	assert.Len(t, exp.config.MetricDeclarations[2].Dimensions, 1)
 
 	// Test output warning logs
 	expectedLogs := []observer.LoggedEntry{

exporter/awsemfexporter/grouped_metric_test.go

@@ -116,11 +116,11 @@ func TestAddToGroupedMetric(t *testing.T) {
 				assert.NoError(t, err)
 			}
 
-			assert.Equal(t, 1, len(groupedMetrics))
+			assert.Len(t, groupedMetrics, 1)
 			for _, v := range groupedMetrics {
 				assert.Equal(t, len(tc.expectedMetricInfo), len(v.metrics))
 				assert.Equal(t, tc.expectedMetricInfo, v.metrics)
-				assert.Equal(t, 2, len(v.labels))
+				assert.Len(t, v.labels, 2)
 				assert.Equal(t, generateTestMetricMetadata(namespace, timestamp, logGroup, logStreamName, instrumentationLibName, tc.expectedMetricType), v.metadata)
 				assert.Equal(t, tc.expectedLabels, v.labels)
 			}
@@ -158,7 +158,7 @@ func TestAddToGroupedMetric(t *testing.T) {
 			assert.NoError(t, err)
 		}
 
-		assert.Equal(t, 4, len(groupedMetrics))
+		assert.Len(t, groupedMetrics, 4)
 		for _, group := range groupedMetrics {
 			for metricName, metricInfo := range group.metrics {
 				switch metricName {
@@ -230,7 +230,7 @@ func TestAddToGroupedMetric(t *testing.T) {
 			assert.NoError(t, err)
 		}
 
-		assert.Equal(t, 4, len(groupedMetrics))
+		assert.Len(t, groupedMetrics, 4)
 		for _, group := range groupedMetrics {
 			for metricName, metricInfo := range group.metrics {
 				switch metricName {
@@ -348,7 +348,7 @@ func TestAddToGroupedMetric(t *testing.T) {
 			)
 			assert.NoError(t, err)
 		}
-		assert.Equal(t, 1, len(groupedMetrics))
+		assert.Len(t, groupedMetrics, 1)
 
 		labels := map[string]string{
 			oTellibDimensionKey: instrumentationLibName,
@@ -389,7 +389,7 @@ func TestAddToGroupedMetric(t *testing.T) {
 			emfCalcs,
 		)
 		assert.NoError(t, err)
-		assert.Equal(t, 0, len(groupedMetrics))
+		assert.Len(t, groupedMetrics, 0)
 
 		// Test output warning logs
 		expectedLogs := []observer.LoggedEntry{

exporter/awsemfexporter/metric_declaration_test.go

@@ -226,7 +226,7 @@ func TestMetricDeclarationInit(t *testing.T) {
 		}
 		err := m.init(logger)
 		assert.NoError(t, err)
-		assert.Equal(t, 3, len(m.metricRegexList))
+		assert.Len(t, m.metricRegexList, 3)
 	})
 
 	t.Run("with dimensions", func(t *testing.T) {
@@ -239,8 +239,8 @@ func TestMetricDeclarationInit(t *testing.T) {
 		}
 		err := m.init(logger)
 		assert.NoError(t, err)
-		assert.Equal(t, 3, len(m.metricRegexList))
-		assert.Equal(t, 2, len(m.Dimensions))
+		assert.Len(t, m.metricRegexList, 3)
+		assert.Len(t, m.Dimensions, 2)
 	})
 
 	// Test removal of dimension sets with more than 10 elements
@@ -256,8 +256,8 @@ func TestMetricDeclarationInit(t *testing.T) {
 		obsLogger := zap.New(obs)
 		err := m.init(obsLogger)
 		assert.NoError(t, err)
-		assert.Equal(t, 3, len(m.metricRegexList))
-		assert.Equal(t, 1, len(m.Dimensions))
+		assert.Len(t, m.metricRegexList, 3)
+		assert.Len(t, m.Dimensions, 1)
 		// Check logged warning message
 		expectedLogs := []observer.LoggedEntry{{
 			Entry:   zapcore.Entry{Level: zap.WarnLevel, Message: "Dropped dimension set: > 10 dimensions specified."},
@@ -281,7 +281,7 @@ func TestMetricDeclarationInit(t *testing.T) {
 		obsLogger := zap.New(obs)
 		err := m.init(obsLogger)
 		assert.NoError(t, err)
-		assert.Equal(t, 1, len(m.Dimensions))
+		assert.Len(t, m.Dimensions, 1)
 		assert.Equal(t, []string{"a", "b", "c"}, m.Dimensions[0])
 		// Check logged warning message
 		expectedLogs := []observer.LoggedEntry{
@@ -324,7 +324,7 @@ func TestMetricDeclarationInit(t *testing.T) {
 		}
 		err := m.init(logger)
 		assert.NoError(t, err)
-		assert.Equal(t, 2, len(m.LabelMatchers))
+		assert.Len(t, m.LabelMatchers, 2)
 		assert.Equal(t, ";", m.LabelMatchers[0].Separator)
 		assert.Equal(t, ".+", m.LabelMatchers[0].Regex)
 		assert.NotNil(t, m.LabelMatchers[0].compiledRegex)