internal_metrics_test.go

// Copyright The OpenTelemetry Authors
// SPDX-License-Identifier: Apache-2.0

package integration

import (
	"net/http"
	"path"
	"strconv"
	"testing"
	"time"

	"github.com/prometheus/common/expfmt"
	"github.com/prometheus/common/model"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"

	dockercompose "go.opentelemetry.io/obi/internal/test/integration/components/docker"
	"go.opentelemetry.io/obi/internal/test/integration/components/promtest"
	ti "go.opentelemetry.io/obi/pkg/test/integration"
)

func TestInstrumentationErrors(t *testing.T) {
	compose, err := dockercompose.ComposeSuite("docker-compose-error-test.yml", path.Join(pathOutput, "test-suite-instrumentation-errors.log"))
	require.NoError(t, err)

	// Run OBI without privileged mode to force instrumentation errors
	compose.Env = append(compose.Env, `OTEL_EBPF_EXECUTABLE_PATH=`, `OTEL_EBPF_OPEN_PORT=`)
	require.NoError(t, compose.Up())

	t.Run("Instrumentation error metrics", func(t *testing.T) {
		checkInstrumentationErrorMetrics(t)
	})

	require.NoError(t, compose.Close())
}

func TestAvoidedServicesMetrics(t *testing.T) {
	network := setupDockerNetwork(t)
	setupContainerPrometheus(t, network, "prometheus-config.yml")
	setupContainerJaeger(t, network)
	setupContainerCollector(t, network, "otelcol-config.yml")
	setupGoOTelTestServer(t, network, []string{
		"OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=http://otelcol:4318",
		"OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=http://jaeger:4318",
	})

	if t.Failed() {
		return
	}

	// Start OBI to instrument the test server
	o := obi{
		Env: []string{
			"OTEL_EBPF_OPEN_PORT=8080",
			"OTEL_EBPF_INTERNAL_METRICS_PROMETHEUS_PORT=8999",
		},
	}
	if !KernelLockdownMode() {
		o.SecurityConfigSuffix = "_none"
	}
	o.instrument(t, network, "obi-config-go-otel.yml")

	t.Run("Avoided services metrics are recorded", func(t *testing.T) {
		// Wait for the service to start and make some requests to trigger OTLP detection
		otelWaitForTestComponents(t, "http://localhost:8080", "/smoke")

		// Give time for the service to export metrics/traces
		time.Sleep(15 * time.Second)

		// Make additional requests to ensure OTLP endpoints are hit
		for i := 0; i < 3; i++ {
			ti.DoHTTPGet(t, "http://localhost:8080/rolldice", 200)
			time.Sleep(1 * time.Second)
		}

		// Check that avoided services metrics are present
		checkAvoidedServicesMetrics(t)
	})
}

func checkInstrumentationErrorMetrics(t *testing.T) {
	pq := promtest.Client{HostPort: prometheusHostPort}
	require.EventuallyWithT(t, func(ct *assert.CollectT) {
		results, err := pq.Query(`obi_instrumentation_errors_total`)
		require.NoError(ct, err)

		require.GreaterOrEqual(ct, len(results), 1, "obi_instrumentation_errors_total metric should be present")

		// Verify we have some errors and proper labels
		totalErrors := 0
		for _, result := range results {
			labels := result.Metric
			require.Contains(ct, labels, "process_name", "process_name label should be present")
			require.Contains(ct, labels, "error_type", "error_type label should be present")

			value, err := strconv.Atoi(result.Value[1].(string))
			require.NoError(ct, err)
			totalErrors += value
		}

		// We should have at least some errors when running without privileges
		require.Positive(ct, totalErrors, "Should have instrumentation errors when running without privileges")
	}, testTimeout, 1000*time.Millisecond)
}

func checkAvoidedServicesMetrics(t *testing.T) {
	const internalMetricsURL = "http://localhost:8999/internal/metrics"

	require.EventuallyWithT(t, func(ct *assert.CollectT) {
		parser := expfmt.NewTextParser(model.UTF8Validation)
		resp, err := http.Get(internalMetricsURL)
		require.NoError(ct, err)
		require.Equal(ct, http.StatusOK, resp.StatusCode)

		metrics, err := parser.TextToMetricFamilies(resp.Body)
		require.NoError(ct, err)

		metricFamily, ok := metrics["obi_avoided_services"]
		require.True(ct, ok, "Expected obi_avoided_services metric to be present")
		require.NotEmpty(ct, metricFamily.Metric, "Expected avoided services metrics to have values")

		// Just check the first occurrence
		metric := metricFamily.Metric[0]
		labelMap := make(map[string]string)
		for _, label := range metric.Label {
			labelMap[label.GetName()] = label.GetValue()
		}

		// Assert specific values for service_name and service_namespace
		assert.Equal(ct, "rolldice", labelMap["service_name"], "service_name label should be 'rolldice'")
		assert.Equal(ct, "integration-test", labelMap["service_namespace"], "service_namespace label should be 'integration-test'")
		assert.NotEmpty(ct, labelMap["telemetry_type"], "telemetry_type label should not be empty")
		assert.Condition(ct, func() bool {
			return labelMap["telemetry_type"] == "metrics" || labelMap["telemetry_type"] == "traces"
		}, "telemetry_type label should be either 'metrics' or 'traces'")

		if metric.Gauge != nil {
			assert.Greater(ct, metric.Gauge.GetValue(), float64(0), "Expected avoided service metric value to be > 0")
		}
	}, testTimeout, 1000*time.Millisecond)
}