Merge pull request #14 from EncoreTechnologies/feature/slack-alerts-trigger

feature/slack-alerts-trigger

Author: bishopbm1

CHANGES.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## v1.0.2
+
+ * Adds new trigger payload to track previous state
+
+Contributed by Jacob Huff (Encore Technologies)
+
 ## v1.0.1
 
  * Enabling sensor in sensor parameters
@@ -18,7 +24,7 @@ Switches stackstorm-ci url to an ssh url
 
 ## v0.1.1
 
-Fixes the following bugs/issues: 
+Fixes the following bugs/issues:
 	- executions where all tasks succeed but workflow fails were not detected
 	- adds support for generic StackStorm errors like timouts
 	- removes byte conversions to unicode

pack.yaml

@@ -2,10 +2,10 @@
 ref: errors
 name: errors
 description: Error pack used to generate errors for tasks/workflows
-keywords: 
+keywords:
     - cookiecutter
     - errors
-version: 1.0.1
+version: 1.0.2
 author: Alex Chrystal
 email: [email protected]
 python_versions:

sensors/cron_sensor.py

@@ -71,6 +71,7 @@ def __init__(self, sensor_service, config=None, poll_interval=None):
                                          poll_interval=poll_interval)
         self._logger = self._sensor_service.get_logger(__name__)
         self.trigger_ref = "errors.error_cron_event"
+        self.enhanced_trigger_ref = "errors.error_cron_event_enhanced"
 
     def setup(self):
         self.st2_fqdn = socket.getfqdn()
@@ -96,6 +97,9 @@ def poll(self):
         if not isinstance(self.kv_enforcements, dict):
             self.kv_enforcements = ast.literal_eval(self.kv_enforcements)
 
+        # Convert to new format temporarily for migration but keep using original format
+        self._migrated_kv = self._migrate_kv_format(self.kv_enforcements)
+
         self._logger.info("Current problem rules: {0}".format(self.kv_enforcements))
 
         for rule in rules:
@@ -199,21 +203,33 @@ def dispatch_trigger(self,
                          st2_comments="",
                          st2_enforcement_id=None,
                          st2_state="error"):
+        previous_state = self._get_previous_state(st2_rule_name)
+
         trigger_payload = {
             'st2_rule_name': st2_rule_name,
             'st2_server': st2_server,
             'st2_execution_id': st2_execution_id,
             'st2_comments': st2_comments,
             'st2_state': st2_state
         }
+
+        enhanced_trigger_payload = trigger_payload.copy()
+        enhanced_trigger_payload['st2_previous_state'] = previous_state
+
         if st2_state == "success":
             self._sensor_service.dispatch(trigger=self.trigger_ref, payload=trigger_payload)
+            self._sensor_service.dispatch(trigger=self.enhanced_trigger_ref,
+                                          payload=enhanced_trigger_payload)
             return True
 
         if self.check_before_dispatch(st2_rule_name, st2_enforcement_id):
             self._logger.info("Sending trigger with payload: {0}".format(trigger_payload))
+            self._logger.info("Sending enhanced trigger with previous state: {0}".format(
+                previous_state))
 
             self._sensor_service.dispatch(trigger=self.trigger_ref, payload=trigger_payload)
+            self._sensor_service.dispatch(trigger=self.enhanced_trigger_ref,
+                                          payload=enhanced_trigger_payload)
 
             if st2_enforcement_id:
                 self.kv_enforcements[st2_rule_name] = st2_enforcement_id
@@ -222,7 +238,7 @@ def dispatch_trigger(self,
 
         else:
             self._logger.info("Already dispatched trigger. Waiting till another enforcement before"
-                             " dispatching another trigger.")
+                              " dispatching another trigger.")
 
         return True
 
@@ -280,6 +296,30 @@ def convert_to_crontab(self, st2_cron):
 
         return " ".join(cron_tab)
 
+    def _migrate_kv_format(self, kv_data):
+        """ Migrates old key-value format to new enhanced format
+        Old: {'rule_name': 'enforcement_id'}
+        New: {'rule_name': {'enforcement_id': 'id', 'previous_state': 'state'}}
+        """
+        migrated_data = {}
+        for rule_name, value in kv_data.items():
+            if isinstance(value, dict):
+                # Already in new format
+                migrated_data[rule_name] = value
+            else:
+                # Old format - migrate
+                migrated_data[rule_name] = {
+                    'enforcement_id': value,
+                    'previous_state': 'unknown'
+                }
+        return migrated_data
+
+    def _get_previous_state(self, rule_name):
+        """ Gets the previous state for a rule """
+        if rule_name in self._migrated_kv:
+            return self._migrated_kv[rule_name].get('previous_state', 'unknown')
+        return 'unknown'
+
     def cleanup(self):
         pass
 

sensors/cron_sensor.yaml

@@ -33,3 +33,29 @@
           st2_state:
             type: "string"
             format: "The state that the error event should be in"
+    -
+      name: "error_cron_event_enhanced"
+      description: "Enhanced trigger with previous state tracking for cron job state transitions"
+      payload_schema:
+        type: "object"
+        properties:
+          st2_comments:
+            type: "string"
+            format: "Comments on what is happening with the cron job."
+          st2_execution_id:
+            type: "string"
+            format: "Stackstorm execution id"
+            default: ""
+          st2_rule_name:
+            type: "string"
+            format: "Stackstorm rule name"
+          st2_server:
+            type: "string"
+            format: "Stackstorm server with the Cron error"
+          st2_state:
+            type: "string"
+            format: "The current state that the error event should be in"
+          st2_previous_state:
+            type: "string"
+            format: "The previous state of the cron job for tracking state transitions"
+            default: "unknown"

tests/test_sensor_cron_sensor.py

@@ -273,7 +273,7 @@ def test_check_enforcements_no_execution(self):
                                      enforced_at='2018-10-26T01:00:00.01Z',
                                      rule={'ref': 'test_rule'})
         mock_rule_enforcement = mock.Mock(id="test_id",
-                                         failure_reason="test_failure")
+                                          failure_reason="test_failure")
 
         mock_st2_client = mock.MagicMock()
         mock_st2_client.ruleenforcements.get_by_id.return_value = mock_rule_enforcement
@@ -309,7 +309,7 @@ def test_check_enforcements_no_execution_jinja_escaping(self):
                                      enforced_at='2018-10-26T01:00:00.01Z',
                                      rule={'ref': 'test_rule'})
         mock_rule_enforcement = mock.Mock(id="test_id",
-                                         failure_reason='{{ test_failure }}')
+                                          failure_reason='{{ test_failure }}')
 
         mock_st2_client = mock.MagicMock()
         mock_st2_client.ruleenforcements.get_by_id.return_value = mock_rule_enforcement
@@ -341,8 +341,8 @@ def test_check_enforcements_true(self):
         sensor.kv_enforcements = {}
 
         mock_enforcement = mock.Mock(enforced_at='2018-10-26T01:00:00.01Z',
-                                    execution_id='test',
-                                    rule={'ref': 'test_rule'})
+                                     execution_id='test',
+                                     rule={'ref': 'test_rule'})
         mock_execution = mock.Mock(status='succeeded')
 
         mock_st2_client = mock.MagicMock()
@@ -487,3 +487,119 @@ def test_convert_to_crontab_day_convert(self):
         expected_return = '* * * * * 4 *'
         result_value = sensor.convert_to_crontab(test_dict)
         self.assertEqual(result_value, expected_return)
+
+    # Enhanced functionality tests
+    def test_migrate_kv_format_old_to_new(self):
+        sensor = self.get_sensor_instance()
+        old_format = {
+            'rule1': 'enforcement_id_1',
+            'rule2': 'error without enforcement id'
+        }
+
+        result = sensor._migrate_kv_format(old_format)
+
+        expected = {
+            'rule1': {'enforcement_id': 'enforcement_id_1', 'previous_state': 'unknown'},
+            'rule2': {'enforcement_id': 'error without enforcement id', 'previous_state': 'unknown'}
+        }
+        self.assertEqual(result, expected)
+
+    def test_migrate_kv_format_already_new(self):
+        sensor = self.get_sensor_instance()
+        new_format = {
+            'rule1': {'enforcement_id': 'enforcement_id_1', 'previous_state': 'error'}
+        }
+
+        result = sensor._migrate_kv_format(new_format)
+        self.assertEqual(result, new_format)
+
+    def test_get_previous_state(self):
+        sensor = self.get_sensor_instance()
+        sensor.kv_enforcements = {
+            'rule1': {'enforcement_id': 'id1', 'previous_state': 'error'},
+            'rule2': {'enforcement_id': 'id2'}  # missing previous_state
+        }
+
+        self.assertEqual(sensor._get_previous_state('rule1'), 'error')
+        self.assertEqual(sensor._get_previous_state('rule2'), 'unknown')
+        self.assertEqual(sensor._get_previous_state('nonexistent'), 'unknown')
+
+    def test_set_rule_state(self):
+        sensor = self.get_sensor_instance()
+        sensor.kv_enforcements = {}
+
+        sensor._set_rule_state('test_rule', 'test_enforcement', 'error')
+
+        expected = {'test_rule': {'enforcement_id': 'test_enforcement', 'previous_state': 'error'}}
+        self.assertEqual(sensor.kv_enforcements, expected)
+
+    def test_enhanced_trigger_dispatch_error(self):
+        sensor = self.get_sensor_instance()
+        sensor.st2_fqdn = 'st2_test'
+        sensor.kv_enforcements = {}
+
+        test_dict = {
+            'st2_rule_name': 'test_rule',
+            'st2_server': 'st2_test',
+            'st2_execution_id': 'st2_test_execution',
+            'st2_comments': 'test_comments',
+            'st2_state': 'error'
+        }
+
+        sensor.dispatch_trigger(**test_dict)
+
+        # Check both triggers were dispatched
+        trigger_payload = {
+            'st2_rule_name': 'test_rule',
+            'st2_server': 'st2_test',
+            'st2_execution_id': 'st2_test_execution',
+            'st2_comments': 'test_comments',
+            'st2_state': 'error'
+        }
+
+        enhanced_trigger_payload = trigger_payload.copy()
+        enhanced_trigger_payload['st2_previous_state'] = 'unknown'
+
+        self.assertTriggerDispatched(trigger='errors.error_cron_event',
+                                     payload=trigger_payload)
+        self.assertTriggerDispatched(trigger='errors.error_cron_event_enhanced',
+                                     payload=enhanced_trigger_payload)
+
+    def test_enhanced_trigger_dispatch_success_with_previous_error(self):
+        sensor = self.get_sensor_instance()
+        sensor.st2_fqdn = 'st2_test'
+        sensor.kv_enforcements = {'test_rule': {'enforcement_id': 'old_id',
+                                                'previous_state': 'error'}}
+
+        test_dict = {
+            'st2_rule_name': 'test_rule',
+            'st2_server': 'st2_test',
+            'st2_execution_id': 'new_execution',
+            'st2_comments': 'Cronjob recovered',
+            'st2_state': 'success',
+            'st2_enforcement_id': 'new_enforcement'
+        }
+
+        sensor.dispatch_trigger(**test_dict)
+
+        # Check both triggers were dispatched
+        trigger_payload = {
+            'st2_rule_name': 'test_rule',
+            'st2_server': 'st2_test',
+            'st2_execution_id': 'new_execution',
+            'st2_comments': 'Cronjob recovered',
+            'st2_state': 'success'
+        }
+
+        enhanced_trigger_payload = trigger_payload.copy()
+        enhanced_trigger_payload['st2_previous_state'] = 'error'
+
+        self.assertTriggerDispatched(trigger='errors.error_cron_event',
+                                     payload=trigger_payload)
+        self.assertTriggerDispatched(trigger='errors.error_cron_event_enhanced',
+                                     payload=enhanced_trigger_payload)
+
+        # Verify state was updated
+        expected_kv = {'test_rule': {'enforcement_id': 'new_enforcement',
+                                     'previous_state': 'success'}}
+        self.assertEqual(sensor.kv_enforcements, expected_kv)