Added first logic for variables in custom annotations and labels #7

Author: StefanHufschmidt

src/main/java/de/gdata/mobilelab/alertmanagercallback/AlertManagerPayloadBuilder.java

@@ -1,13 +1,21 @@
 package de.gdata.mobilelab.alertmanagercallback;
 
+import com.floreysoft.jmte.Engine;
+import org.graylog2.plugin.Message;
+import org.graylog2.plugin.MessageSummary;
 import org.graylog2.plugin.alarms.AlertCondition;
 import org.graylog2.plugin.configuration.Configuration;
 import org.graylog2.plugin.streams.Stream;
 import org.joda.time.DateTime;
 
 import java.io.IOException;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
+
+import static com.google.common.base.MoreObjects.firstNonNull;
 
 class AlertManagerPayloadBuilder {
 
@@ -17,10 +25,12 @@ class AlertManagerPayloadBuilder {
     private AlertCondition.CheckResult checkResult;
     private Configuration configuration;
     private CustomPropertiesTextFieldParser customPropertiesTextFieldParser;
+    private Engine templateEngine;
 
     private AlertManagerPayloadBuilder() {
         // Private constructor to hide the implicit one
         customPropertiesTextFieldParser = new CustomPropertiesTextFieldParser();
+        templateEngine = new Engine();
     }
 
     static AlertManagerPayloadBuilder newInstance() {
@@ -45,7 +55,24 @@ AlertManagerPayloadBuilder withConfiguration(Configuration configuration) {
         return this;
     }
 
+    // parts copied from org.graylog2.alerts.FormattedEmailAlertSender#getModel()
+    private Map<String, Object> createModel(Stream stream, AlertCondition.CheckResult checkResult, List<Message> backlog) {
+        Map<String, Object> model = new HashMap<>();
+        model.put("stream", stream);
+        model.put("check_result", checkResult);
+        model.put("stream_url", extractStreamUrl());
+        model.put("alertCondition", checkResult.getTriggeredCondition());
+
+        final List<Message> messages = firstNonNull(backlog, Collections.emptyList());
+        model.put("backlog", messages);
+        model.put("backlog_size", messages.size());
+
+        return model;
+    }
+
     AlertManagerPayload build() {
+
+
         AlertManagerPayload alertManagerPayload = new AlertManagerPayload();
         alertManagerPayload.setAnnotations(extractAnnotations());
         alertManagerPayload.setLabels(extractLabels());
@@ -72,9 +99,35 @@ private Map<String, Object> extractLabels() {
             // damaged configuration, so we'll not put any additional label into the map
         }
 
+        transformTemplateValues(labels);
+
         return labels;
     }
 
+    private void transformTemplateValues(Map<String, Object> customValueMap) {
+        customValueMap.entrySet().forEach(
+                entry -> {
+                        try {
+                            if (entry.getValue() != null) {
+                                String valueAsString = (String) entry.getValue();
+                                entry.setValue(templateEngine.transform(
+                                        valueAsString,
+                                        createModel(
+                                                stream,
+                                                checkResult,
+                                                checkResult.getMatchingMessages().stream()
+                                                        .map(MessageSummary::getRawMessage)
+                                                        .collect(Collectors.toList())
+                                        )
+                                ));
+                            }
+                        } catch (Exception ex) {
+                            // Just catch exceptions for bad formatting or direct values which should not be formatted
+                        }
+                }
+        );
+    }
+
     private Map<String, Object> extractAnnotations() {
         Map<String, Object> annotations = new HashMap<>();
 
@@ -98,6 +151,8 @@ private Map<String, Object> extractAnnotations() {
             // damaged configuration, so we'll not put any additional annotation into the map
         }
 
+        transformTemplateValues(annotations);
+
         return annotations;
     }
 

src/test/java/de/gdata/mobilelab/alertmanagercallback/AlertManagerPayloadBuilderTest.java

@@ -10,12 +10,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.*;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -472,4 +467,59 @@ public void buildWithStrangeNotatedCustomAnnotations() {
         assertEquals("production=staging", alertManagerPayload.getAnnotations().get("system"));
         assertEquals(2, alertManagerPayload.getAnnotations().size());
     }
+
+    @Test
+    public void buildWithCustomTemplateAnnotations() {
+        // given: configuration mock
+        Configuration configuration = mock(Configuration.class);
+        when(configuration.getString("alertmanager_custom_annotations"))
+                .thenReturn(
+                        "mystreamtitle=${stream.title};"
+                                + "myresultdesc=${check_result.resultDescription};"
+                                + "mytriggeredat=${check_result.triggeredAt};"
+                                + "mystreamid=${stream.id};"
+                                + "mystreamdescription=${stream.description};"
+                                + "myalertconditiontitle=${alertCondition.title};"
+                                + "myalertconditiondesc=${alertCondition.description};"
+                                + "mytriggeredcondition=${check_result.triggeredCondition};"
+                );
+
+        // and: stream mock
+        Stream stream = mock(Stream.class);
+        when(stream.getTitle()).thenReturn("StreamTitle");
+        when(stream.getId()).thenReturn("StreamId");
+        when(stream.getDescription()).thenReturn("StreamDescription");
+
+        // and: checkResult mock
+        AlertCondition.CheckResult checkResult = mock(AlertCondition.CheckResult.class);
+        DateTime triggeredAt = new DateTime();
+        when(checkResult.getTriggeredAt()).thenReturn(triggeredAt);
+        when(checkResult.getResultDescription()).thenReturn("CheckResultResultDescription");
+        AlertCondition alertCondition = mock(AlertCondition.class);
+        when(alertCondition.toString()).thenReturn("TriggeredConditionString");
+        when(alertCondition.getDescription()).thenReturn("AlertDescription");
+        when(alertCondition.getTitle()).thenReturn("AlertTitle");
+        when(checkResult.getTriggeredCondition()).thenReturn(alertCondition);
+
+
+        // and: instance with set mocks as values
+        AlertManagerPayload alertManagerPayload = AlertManagerPayloadBuilder.newInstance()
+                .withConfiguration(configuration)
+                .withStream(stream)
+                .withCheckResult(checkResult)
+                .build();
+
+        // expect: correct values set
+        // - annotations
+        assertEquals("StreamTitle", alertManagerPayload.getAnnotations().get("mystreamtitle"));
+        assertEquals("CheckResultResultDescription", alertManagerPayload.getAnnotations().get("myresultdesc"));
+        assertNotNull(alertManagerPayload.getAnnotations().get("mytriggeredat"));
+        assertNotEquals("", alertManagerPayload.getAnnotations().get("mytriggeredat"));
+        assertEquals("StreamId", alertManagerPayload.getAnnotations().get("mystreamid"));
+        assertEquals("StreamDescription", alertManagerPayload.getAnnotations().get("mystreamdescription"));
+        assertEquals("AlertTitle", alertManagerPayload.getAnnotations().get("myalertconditiontitle"));
+        assertEquals("AlertDescription", alertManagerPayload.getAnnotations().get("myalertconditiondesc"));
+        assertEquals("TriggeredConditionString", alertManagerPayload.getAnnotations().get("mytriggeredcondition"));
+        assertEquals(12, alertManagerPayload.getAnnotations().size());
+    }
 }