[exporter/alertmanager] Add alert labels from event attributes list open-telemetry#38063

Author: mcube8

.chloggen/add-eventlabels-alertmanagerexporter.yaml

@@ -0,0 +1,27 @@
+# Use this changelog template to create an entry for release notes.
+
+# One of 'breaking', 'deprecation', 'new_component', 'enhancement', 'bug_fix'
+change_type: enhancement
+
+# The name of the component, or a single word describing the area of concern, (e.g. filelogreceiver)
+component: alertmanagerexporter
+
+# A brief description of the change.  Surround your text with quotes ("") if it needs to start with a backtick (`).
+note: Add alert labels based on event attribute list in alermanager exporter
+
+# Mandatory: One or more tracking issues related to the change. You can use the PR number here if no issue exists.
+issues: [38063]
+
+# (Optional) One or more lines of additional information to render under the primary note.
+# These lines will be padded with 2 spaces and then inserted directly into the document.
+# Use pipe (|) for multiline entries.
+subtext:
+
+# If your change doesn't affect end users or the exported elements of any package,
+# you should instead start your pull request title with [chore] or use the "Skip Changelog" label.
+# Optional: The change log or logs in which this entry should be included.
+# e.g. '[user]' or '[user, api]'
+# Include 'user' if the change is relevant to end users.
+# Include 'api' if there is a change to a library API.
+# Default: '[user]'
+change_logs: [user]

exporter/alertmanagerexporter/README.md

@@ -30,6 +30,7 @@ The following settings are optional:
 - `generator_url` is the source of the alerts to be used in Alertmanager's payload. The default value is "opentelemetry-collector", and can be set to the URL of the opentelemetry collector.
 - `severity_attribute` is the SpanEvent Attribute name which can be used instead of default severity string in Alert payload
    e.g.: If `severity_attribute` is set to "foo" and the SpanEvent has an attribute called foo, foo's attribute value will be used as the severity value for that particular Alert generated from the SpanEvent.
+- `event_labels` is the list of Event Attributes that will be captured as Labels in the Alert payload if value exists.
 
 
 Example config:
@@ -41,6 +42,7 @@ exporters:
     endpoint: "https://a.new.alertmanager.target:9093"
     severity: "debug"
     severity_attribute: "foo"
+    event_labels: ["foo", "bar"]
     tls:
       cert_file: /var/lib/mycert.pem
       key_file: /var/lib/key.pem

exporter/alertmanagerexporter/alertmanager_exporter.go

@@ -10,6 +10,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"slices"
 	"time"
 
 	"github.com/prometheus/common/model"
@@ -104,15 +105,28 @@ func createAnnotations(event *alertmanagerEvent) model.LabelSet {
 	return labelMap
 }
 
+func (s *alertmanagerExporter) createLabels(event *alertmanagerEvent) model.LabelSet {
+	labelMap := model.LabelSet{}
+	for key, attr := range event.spanEvent.Attributes().All() {
+		if slices.Contains(s.config.EventLabels, key) {
+			labelMap[model.LabelName(key)] = model.LabelValue(attr.AsString())
+		}
+	}
+	labelMap["severity"] = model.LabelValue(event.severity)
+	labelMap["event_name"] = model.LabelValue(event.spanEvent.Name())
+	return labelMap
+}
+
 func (s *alertmanagerExporter) convertEventsToAlertPayload(events []*alertmanagerEvent) []model.Alert {
 	payload := make([]model.Alert, len(events))
 
 	for i, event := range events {
 		annotations := createAnnotations(event)
+		labels := s.createLabels(event)
 
 		alert := model.Alert{
 			StartsAt:     time.Now(),
-			Labels:       model.LabelSet{"severity": model.LabelValue(event.severity), "event_name": model.LabelValue(event.spanEvent.Name())},
+			Labels:       labels,
 			Annotations:  annotations,
 			GeneratorURL: s.generatorURL,
 		}

exporter/alertmanagerexporter/alertmanager_exporter_test.go

@@ -151,6 +151,7 @@ func TestAlertManagerExporterSeverity(t *testing.T) {
 	factory := NewFactory()
 	cfg := factory.CreateDefaultConfig().(*Config)
 	cfg.SeverityAttribute = "foo"
+	cfg.EventLabels = []string{}
 	set := exportertest.NewNopSettings(metadata.Type)
 	am := newAlertManagerExporter(cfg, set.TelemetrySettings)
 	require.NotNil(t, am)
@@ -199,7 +200,7 @@ func TestAlertManagerExporterNoDefaultSeverity(t *testing.T) {
 	set := exportertest.NewNopSettings(metadata.Type)
 	am := newAlertManagerExporter(cfg, set.TelemetrySettings)
 	require.NotNil(t, am)
-
+	cfg.EventLabels = []string{}
 	// make traces & a span
 	traces, span := createTracesAndSpan()
 
@@ -228,6 +229,7 @@ func TestAlertManagerExporterAlertPayload(t *testing.T) {
 	cfg := factory.CreateDefaultConfig().(*Config)
 	set := exportertest.NewNopSettings(metadata.Type)
 	am := newAlertManagerExporter(cfg, set.TelemetrySettings)
+	cfg.EventLabels = []string{}
 
 	require.NotNil(t, am)
 
@@ -277,6 +279,50 @@ func TestAlertManagerTracesExporterNoErrors(t *testing.T) {
 	assert.NoError(t, err)
 }
 
+func TestAlertManagerExporterEventLabels(t *testing.T) {
+	factory := NewFactory()
+	cfg := factory.CreateDefaultConfig().(*Config)
+	set := exportertest.NewNopSettings(metadata.Type)
+	am := newAlertManagerExporter(cfg, set.TelemetrySettings)
+	require.NotNil(t, am)
+
+	// make traces & a span
+	_, span := createTracesAndSpan()
+
+	// add a span event w/ 3 attributes
+	event := span.Events().AppendEmpty()
+	// add event attributes
+	startTime := pcommon.Timestamp(time.Now().UnixNano())
+	event.SetTimestamp(startTime + 3)
+	event.SetName("unittest-event")
+	attrs := event.Attributes()
+	attrs.Clear()
+	attrs.EnsureCapacity(4)
+	attrs.PutStr("attr1", "unittest-baz")
+	attrs.PutInt("attr2", 42)
+	attrs.PutDouble("attr3", 5.14)
+
+	var events []*alertmanagerEvent
+	events = append(events, &alertmanagerEvent{
+		spanEvent: event,
+		severity:  am.defaultSeverity,
+		traceID:   "0000000000000002",
+		spanID:    "00000002",
+	})
+
+	got := am.convertEventsToAlertPayload(events)
+
+	// test - count of attributes
+	expect := model.Alert{
+		Labels:       model.LabelSet{"severity": "info", "event_name": "unittest-event", "attr1": "unittest-baz", "attr2": "42"},
+		Annotations:  model.LabelSet{"SpanID": "00000002", "TraceID": "0000000000000002", "attr1": "unittest-baz", "attr2": "42", "attr3": "5.14"},
+		GeneratorURL: "opentelemetry-collector",
+	}
+	assert.Equal(t, expect.Labels, got[0].Labels)
+	assert.Equal(t, expect.Annotations, got[0].Annotations)
+	assert.Equal(t, expect.GeneratorURL, got[0].GeneratorURL)
+}
+
 type mockServer struct {
 	mockserver            *httptest.Server // this means mockServer aggregates 'httptest.Server', but can it's more like inheritance in C++
 	fooCalledSuccessfully bool             // this is false by default

exporter/alertmanagerexporter/config.go

@@ -22,6 +22,7 @@ type Config struct {
 	GeneratorURL            string                   `mapstructure:"generator_url"`
 	DefaultSeverity         string                   `mapstructure:"severity"`
 	SeverityAttribute       string                   `mapstructure:"severity_attribute"`
+	EventLabels             []string                 `mapstructure:"event_labels"`
 }
 
 var _ component.Config = (*Config)(nil)

exporter/alertmanagerexporter/config_test.go

@@ -46,6 +46,7 @@ func TestLoadConfig(t *testing.T) {
 				GeneratorURL:      "opentelemetry-collector",
 				DefaultSeverity:   "info",
 				SeverityAttribute: "foo",
+				EventLabels:       []string{"attr1", "attr2"},
 				TimeoutSettings: exporterhelper.TimeoutConfig{
 					Timeout: 10 * time.Second,
 				},

exporter/alertmanagerexporter/factory.go

@@ -34,6 +34,7 @@ func createDefaultConfig() component.Config {
 	return &Config{
 		GeneratorURL:    "opentelemetry-collector",
 		DefaultSeverity: "info",
+		EventLabels:     []string{"attr1", "attr2"},
 		TimeoutSettings: exporterhelper.NewDefaultTimeoutConfig(),
 		BackoffConfig:   configretry.NewDefaultBackOffConfig(),
 		QueueSettings:   exporterhelper.NewDefaultQueueConfig(),