github.com/grafana/synthetic-monitoring-agent@v0.64.2/internal/scraper/labels_test.go

package scraper

import (
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/grafana/synthetic-monitoring-agent/internal/model"
	sm "github.com/grafana/synthetic-monitoring-agent/pkg/pb/synthetic_monitoring"
)

func makeLabels(pairs ...string) []sm.Label {
	if len(pairs)%2 != 0 {
		panic("labels: pairs must be even")
	}

	out := make([]sm.Label, 0, len(pairs)/2)
	for i := 0; i < len(pairs); i += 2 {
		out = append(out, sm.Label{Name: pairs[i], Value: pairs[i+1]})
	}

	return out
}

func findLabel(t *testing.T, lps []labelPair, name string) labelPair {
	t.Helper()

	for _, lp := range lps {
		if lp.name == name {
			return lp
		}
	}

	t.Fatalf("label %q not found in %v", name, lps)

	return labelPair{}
}

func assertNoLabel(t *testing.T, lps []labelPair, name string) {
	t.Helper()

	for _, lp := range lps {
		if lp.name == name {
			t.Errorf("unexpected label %q found in %v", name, lps)
		}
	}
}

// TestBuildUserLabels_Prefixed_CheckOverridesProbe: probe sets env=dev, check sets env=prod.
// Result should be only label_env=prod (check wins, prefixed).
func TestBuildUserLabels_Prefixed_CheckOverridesProbe(t *testing.T) {
	result := buildUserLabels(
		makeLabels("env", "dev"),
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_PREFIXED,
	)
	require.Len(t, result, 1)
	require.Equal(t, "label_env", result[0].name)
	require.Equal(t, "prod", result[0].value)
}

// TestBuildUserLabels_Prefixed_TwoDistinctLabels: probe has region=eu, check has env=prod.
// Both appear prefixed, probe label first.
func TestBuildUserLabels_Prefixed_TwoDistinctLabels(t *testing.T) {
	result := buildUserLabels(
		makeLabels("region", "eu"),
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_PREFIXED,
	)
	require.Len(t, result, 2)
	lp1 := findLabel(t, result, "label_region")
	require.Equal(t, "eu", lp1.value)
	lp2 := findLabel(t, result, "label_env")
	require.Equal(t, "prod", lp2.value)
}

// TestBuildUserLabels_Prefixed_ReservedNotDropped: in PREFIXED mode, reserved names are NOT
// dropped.
func TestBuildUserLabels_Prefixed_ReservedNotDropped(t *testing.T) {
	result := buildUserLabels(
		nil,
		makeLabels("probe", "myprobe"),
		sm.LabelMode_LABEL_MODE_PREFIXED,
	)
	require.Len(t, result, 1)
	require.Equal(t, "label_probe", result[0].name)
	require.Equal(t, "myprobe", result[0].value)
}

// TestBuildUserLabels_DualWrite_Basic: DUAL_WRITE emits all prefixed forms first, then all
// un-prefixed forms: [label_env, env]. The prefixed form comes first so that in the event
// of log stream label overflow, the form existing policies depend on is preserved.
func TestBuildUserLabels_DualWrite_Basic(t *testing.T) {
	result := buildUserLabels(
		nil,
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_DUAL_WRITE,
	)
	require.Len(t, result, 2)
	require.Equal(t, "label_env", result[0].name, "prefixed form must come first")
	require.Equal(t, "prod", result[0].value)
	require.Equal(t, "env", result[1].name, "un-prefixed form must come second")
	require.Equal(t, "prod", result[1].value)
}

// TestBuildUserLabels_DualWrite_TwoLabels: two labels produce [label_a, label_b, a, b] —
// all prefixed first, then all un-prefixed.
func TestBuildUserLabels_DualWrite_TwoLabels(t *testing.T) {
	result := buildUserLabels(
		makeLabels("team", "sre"),
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_DUAL_WRITE,
	)
	require.Len(t, result, 4)
	// First half: all prefixed
	require.Equal(t, "label_team", result[0].name)
	require.Equal(t, "label_env", result[1].name)
	// Second half: all un-prefixed
	require.Equal(t, "team", result[2].name)
	require.Equal(t, "env", result[3].name)
}

// TestBuildUserLabels_DualWrite_CheckOverridesProbe: probe env=dev, check env=prod.
// Both forms should carry the check's value.
func TestBuildUserLabels_DualWrite_CheckOverridesProbe(t *testing.T) {
	result := buildUserLabels(
		makeLabels("env", "dev"),
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_DUAL_WRITE,
	)
	require.Len(t, result, 2)
	require.Equal(t, "label_env", result[0].name)
	require.Equal(t, "prod", result[0].value, "prefixed form should have check value")
	require.Equal(t, "env", result[1].name)
	require.Equal(t, "prod", result[1].value, "un-prefixed form should have check value")
}

// TestBuildUserLabels_DualWrite_ReservedNameDropped: a reserved name keeps its prefixed
// form (label_le, which cannot collide) but its un-prefixed form is dropped so it cannot
// overwrite an intrinsic per-series metric label. Non-reserved names keep both forms.
func TestBuildUserLabels_DualWrite_ReservedNameDropped(t *testing.T) {
	result := buildUserLabels(
		nil,
		makeLabels("le", "user-value", "env", "prod"),
		sm.LabelMode_LABEL_MODE_DUAL_WRITE,
	)
	// [label_le, label_env, env] — the un-prefixed "le" is dropped.
	require.Len(t, result, 3)
	require.Equal(t, "label_le", result[0].name)
	require.Equal(t, "label_env", result[1].name)
	require.Equal(t, "env", result[2].name)
	assertNoLabel(t, result, "le")
}

// TestBuildUserLabels_Unprefixed_Basic: single label env=prod produces only env=prod.
func TestBuildUserLabels_Unprefixed_Basic(t *testing.T) {
	result := buildUserLabels(
		nil,
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_UNPREFIXED,
	)
	require.Len(t, result, 1)
	require.Equal(t, "env", result[0].name)
	require.Equal(t, "prod", result[0].value)
}

// TestBuildUserLabels_Unprefixed_ReservedNameDropped: a reserved name is dropped entirely
// in UNPREFIXED mode; non-reserved names pass through.
func TestBuildUserLabels_Unprefixed_ReservedNameDropped(t *testing.T) {
	result := buildUserLabels(
		nil,
		makeLabels("le", "user-value", "env", "prod"),
		sm.LabelMode_LABEL_MODE_UNPREFIXED,
	)
	require.Len(t, result, 1)
	require.Equal(t, "env", result[0].name)
	assertNoLabel(t, result, "le")
}

// ── customMetricLabels tests ─────────────────────────────────────────────

// TestUserLabelsForExecution_Prefixed: PREFIXED mode returns nil — no user labels on execution metrics.
func TestUserLabelsForExecution_Prefixed(t *testing.T) {
	result := customMetricLabels(
		makeLabels("env", "prod"),
		makeLabels("team", "platform"),
		sm.LabelMode_LABEL_MODE_PREFIXED,
	)
	require.Nil(t, result, "PREFIXED mode should return nil — execution metrics carry no user labels")
}

// TestUserLabelsForExecution_DualWrite: DUAL_WRITE returns only un-prefixed form.
func TestUserLabelsForExecution_DualWrite(t *testing.T) {
	result := customMetricLabels(
		nil,
		makeLabels("env", "prod", "team", "platform"),
		sm.LabelMode_LABEL_MODE_DUAL_WRITE,
	)
	require.Len(t, result, 2, "should emit one entry per user label (un-prefixed only)")
	findLabel(t, result, "env")
	findLabel(t, result, "team")
	assertNoLabel(t, result, "label_env")
	assertNoLabel(t, result, "label_team")
}

// TestUserLabelsForExecution_Unprefixed: UNPREFIXED returns un-prefixed form.
func TestUserLabelsForExecution_Unprefixed(t *testing.T) {
	result := customMetricLabels(
		nil,
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_UNPREFIXED,
	)
	require.Len(t, result, 1)
	require.Equal(t, "env", result[0].name)
	require.Equal(t, "prod", result[0].value)
}

// TestUserLabelsForExecution_ReservedNameDropped: reserved names are dropped from
// execution-metric labels in both DUAL_WRITE and UNPREFIXED, so a user label cannot
// overwrite an intrinsic per-series metric label such as `le`.
func TestUserLabelsForExecution_ReservedNameDropped(t *testing.T) {
	for _, mode := range []sm.LabelMode{sm.LabelMode_LABEL_MODE_DUAL_WRITE, sm.LabelMode_LABEL_MODE_UNPREFIXED} {
		result := customMetricLabels(
			nil,
			makeLabels("le", "user-value", "env", "prod"),
			mode,
		)
		require.Len(t, result, 1)
		require.Equal(t, "env", result[0].name)
		assertNoLabel(t, result, "le")
	}
}

// TestUserLabelsForExecution_CheckOverridesProbe: check label wins over probe label for the same name.
func TestUserLabelsForExecution_CheckOverridesProbe(t *testing.T) {
	result := customMetricLabels(
		makeLabels("env", "staging"),
		makeLabels("env", "prod"),
		sm.LabelMode_LABEL_MODE_DUAL_WRITE,
	)
	require.Len(t, result, 1)
	require.Equal(t, "prod", result[0].value, "check label should override probe label")
}

// ── mergeLogLabels tests ─────────────────────────────────────────────────────

// TestMergeLogLabels_UserWinsSystemOrderingPreserved verifies that user labels
// override colliding system labels in place (user value wins), system labels
// keep their leading positions (so they survive stream-label overflow), and
// non-colliding user labels are appended after the system set. The input system
// slice must not be mutated.
func TestMergeLogLabels_UserWinsSystemOrderingPreserved(t *testing.T) {
	system := []labelPair{
		{name: "probe", value: "p"},
		{name: "job", value: "sysjob"},
		{name: "region", value: "r"},
	}
	user := []labelPair{
		{name: "job", value: "userjob"}, // collides with system "job"
		{name: "env", value: "prod"},    // new
	}

	got := mergeLogLabels(system, user)

	require.Equal(t, []labelPair{
		{name: "probe", value: "p"},
		{name: "job", value: "userjob"}, // user value wins, position preserved
		{name: "region", value: "r"},
		{name: "env", value: "prod"}, // appended after the system labels
	}, got)

	// The input system slice must be left untouched.
	require.Equal(t, "sysjob", system[1].value)
}

// TestMergeLogLabels_NoUserLabels verifies the system labels pass through
// unchanged when there are no user labels.
func TestMergeLogLabels_NoUserLabels(t *testing.T) {
	system := []labelPair{
		{name: "probe", value: "p"},
		{name: "job", value: "sysjob"},
	}

	got := mergeLogLabels(system, nil)

	require.Equal(t, system, got)
}

// TestRegionLabelForMode pins the mode-conditional rename of the agent's
// region label — legacy PREFIXED tenants keep "region"; tenants that have
// started the migration receive "sm_region" (the reserved name) — and the
// invariant the API's alert expressions depend on: for migrated modes,
// sm_region is ALWAYS non-empty. A probe without a region gets the "unset"
// sentinel, because an empty label value is the same as an absent label in
// PromQL, and an absent sm_region classifies the series as pre-migration.
func TestRegionLabelForMode(t *testing.T) {
	require.Equal(t, labelPair{name: "region", value: "EMEA"},
		regionLabelForMode(sm.LabelMode_LABEL_MODE_PREFIXED, "EMEA"))
	require.Equal(t, labelPair{name: "sm_region", value: "EMEA"},
		regionLabelForMode(sm.LabelMode_LABEL_MODE_DUAL_WRITE, "EMEA"))
	require.Equal(t, labelPair{name: "sm_region", value: "EMEA"},
		regionLabelForMode(sm.LabelMode_LABEL_MODE_UNPREFIXED, "EMEA"))

	// Probe without a region: PREFIXED keeps the historical empty value
	// (equivalent to an absent label), preserving legacy series identity.
	require.Equal(t, labelPair{name: "region", value: ""},
		regionLabelForMode(sm.LabelMode_LABEL_MODE_PREFIXED, ""))
	// Migrated modes must never emit an empty sm_region.
	require.Equal(t, labelPair{name: "sm_region", value: "unset"},
		regionLabelForMode(sm.LabelMode_LABEL_MODE_DUAL_WRITE, ""))
	require.Equal(t, labelPair{name: "sm_region", value: "unset"},
		regionLabelForMode(sm.LabelMode_LABEL_MODE_UNPREFIXED, ""))
}

// TestBuildUserLabels_SMRegionDropped pins that a user label named sm_region —
// the reserved name the agent's own region label migrates to — is dropped in
// enforced modes and cannot shadow the agent's value.
func TestBuildUserLabels_SMRegionDropped(t *testing.T) {
	labels := []sm.Label{{Name: "sm_region", Value: "spoofed"}}

	// DUAL_WRITE drops the un-prefixed reserved form but keeps the prefixed
	// form, which cannot collide with the agent's sm_region.
	require.Equal(t,
		[]labelPair{{name: "label_sm_region", value: "spoofed"}},
		buildUserLabels(nil, labels, sm.LabelMode_LABEL_MODE_DUAL_WRITE))
	require.Empty(t, buildUserLabels(nil, labels, sm.LabelMode_LABEL_MODE_UNPREFIXED))
	// In PREFIXED mode it is emitted with the prefix, which cannot collide.
	require.Equal(t,
		[]labelPair{{name: "label_sm_region", value: "spoofed"}},
		buildUserLabels(nil, labels, sm.LabelMode_LABEL_MODE_PREFIXED))
}

// TestBuildCheckInfoLabels_RegionlessProbe pins the sentinel end to end on
// sm_check_info: a migrated tenant's check running on a probe without a
// region still carries a non-empty sm_region (the generation marker the
// API's alert expressions select on), while a PREFIXED tenant's series keeps
// the historical empty region value.
func TestBuildCheckInfoLabels_RegionlessProbe(t *testing.T) {
	s := Scraper{
		checkName: "ping",
		check:     model.Check{Check: sm.Check{Frequency: 60000}},
		probe:     sm.Probe{Name: "regionless"},
	}

	migrated := s.buildCheckInfoLabels(nil, nil, sm.LabelMode_LABEL_MODE_DUAL_WRITE)
	require.Equal(t, "unset", migrated["sm_region"])
	require.NotContains(t, migrated, "region")

	legacy := s.buildCheckInfoLabels(nil, nil, sm.LabelMode_LABEL_MODE_PREFIXED)
	require.Equal(t, "", legacy["region"])
	require.NotContains(t, legacy, "sm_region")
}