Python3 version:

- some cleanings in the monitoring logs: ordering is better (checks before alerts!)

Author: mohierf

alignak/objects/config.py

@@ -1577,8 +1577,7 @@ def explode(self):
         # Serviceescalations hostescalations will create new escalations
         self.serviceescalations.explode(self.escalations)
         self.hostescalations.explode(self.escalations)
-        self.escalations.explode(self.hosts, self.hostgroups,
-                                 self.contactgroups)
+        self.escalations.explode(self.hosts, self.hostgroups, self.contactgroups)
 
         # Now the architecture part
         self.realms.explode()

alignak/objects/escalation.py

@@ -330,25 +330,27 @@ def linkify_es_by_s(self, services):
         :type services: alignak.objects.service.Services
         :return: None
         """
-        for escal in self:
+        for escalation in self:
             # If no host, no hope of having a service
-            if not (hasattr(escal, 'host_name') and hasattr(escal, 'service_description')):
+            if not (hasattr(escalation, 'host_name')):
                 continue
-            es_hname, sdesc = escal.host_name, escal.service_description
-            if '' in (es_hname.strip(), sdesc.strip()):
+
+            es_hname, sdesc = escalation.host_name, escalation.service_description
+            if not es_hname.strip() or not sdesc.strip():
                 continue
+
             for hname in strip_and_uniq(es_hname.split(',')):
                 if sdesc.strip() == '*':
                     slist = services.find_srvs_by_hostname(hname)
                     if slist is not None:
                         slist = [services[serv] for serv in slist]
                         for serv in slist:
-                            serv.escalations.append(escal.uuid)
+                            serv.escalations.append(escalation.uuid)
                 else:
                     for sname in strip_and_uniq(sdesc.split(',')):
                         serv = services.find_srv_by_name_and_hostname(hname, sname)
                         if serv is not None:
-                            serv.escalations.append(escal.uuid)
+                            serv.escalations.append(escalation.uuid)
 
     def linkify_es_by_h(self, hosts):
         """Add each escalation object into host.escalation attribute

alignak/objects/host.py

@@ -600,9 +600,8 @@ def raise_check_result(self):
         elif self.state == 'UNREACHABLE':
             log_level = 'warning'
         brok = make_monitoring_log(
-            log_level, 'ACTIVE HOST CHECK: %s;%s;%s;%d;%s' % (
-                self.get_name(), self.state, self.state_type, self.attempt, self.output
-            )
+            log_level, 'ACTIVE HOST CHECK: %s;%s;%d;%s' % (self.get_name(), self.state,
+                                                           self.attempt, self.output)
         )
         self.broks.append(brok)
 

alignak/objects/hostescalation.py

@@ -119,7 +119,7 @@ def explode(self, escalations):
             name = getattr(escalation, 'host_name', getattr(escalation, 'hostgroup_name', ''))
             creation_dict = {
                 'escalation_name':
-                    'Generated-HostEscalation-%s-%s' % (name, escalation.uuid)
+                    'Generated-HE-%s-%s' % (name, escalation.uuid)
             }
             for prop in properties:
                 if hasattr(escalation, prop):

alignak/objects/item.py

@@ -237,7 +237,7 @@ def __init__(self, params=None, parsing=True):
 
     # Simply moved all the __ functions near the initialization
     def __str__(self):  # pragma: no cover
-        return '<%s name=%r />' % (self.__class__.__name__, self.get_name())
+        return '<%s name=%s />' % (self.__class__.__name__, self.get_name())
     __repr__ = __str__
 
     def init_running_properties(self):

alignak/objects/schedulingitem.py

@@ -1244,10 +1244,6 @@ def schedule(self, hosts, services, timeperiods, macromodulations, checkmodulati
                      self.get_full_name(),
                      datetime.datetime.fromtimestamp(self.next_chk).strftime('%Y-%m-%d %H:%M:%S'),
                      interval, time_add)
-        print("-> schedule: %s / %s (interval: %d, added: %d)",
-                     self.get_full_name(),
-                     datetime.datetime.fromtimestamp(self.next_chk).strftime('%Y-%m-%d %H:%M:%S'),
-                     interval, time_add)
         # Get the command to launch, and put it in queue
         return self.launch_check(self.next_chk, hosts, services, timeperiods, macromodulations,
                                  checkmodulations, checks, force=force)
@@ -1526,7 +1522,7 @@ def update_hard_unknown_phase_state(self):
 
     def consume_result(self, chk, notif_period, hosts,
                        services, timeperiods, macromodulations, checkmodulations, bi_modulations,
-                       res_modulations, checks):
+                       res_modulations, checks, raise_log):
         # pylint: disable=too-many-locals, too-many-arguments
         # pylint: disable=too-many-branches, too-many-statements
         """Consume a check return and send action in return
@@ -1662,6 +1658,10 @@ def consume_result(self, chk, notif_period, hosts,
         self.last_state_type = self.state_type
         self.return_code = chk.exit_status
 
+        # Raise the log only when the item information are up-to-date :/
+        if raise_log:
+            self.raise_check_result()
+
         # we change the state, do whatever we are or not in
         # an impact mode, we can put it
         self.state_changed_since_impact = True
@@ -1889,6 +1889,7 @@ def consume_result(self, chk, notif_period, hosts,
         self.get_perfdata_command(hosts, macromodulations, timeperiods)
         # Also snapshot if need :)
         self.get_snapshot(hosts, macromodulations, timeperiods)
+
         return []
 
     def update_event_and_problem_id(self):
@@ -1977,12 +1978,12 @@ def update_notification_command(self, notif, contact, macromodulations, timeperi
         if cls.enable_environment_macros or notif.enable_environment_macros:
             notif.env = macrosolver.get_env_macros(data)
 
-    def is_escalable(self, notif, escalations, timeperiods):
+    def is_escalable(self, notification, escalations, timeperiods):
         """Check if a notification can be escalated.
         Basically call is_eligible for each escalation
 
-        :param notif: notification we would like to escalate
-        :type notif: alignak.objects.notification.Notification
+        :param notification: notification we would like to escalate
+        :type notification: alignak.objects.notification.Notification
         :param escalations: Esclations objects, used to get escalation objects (period)
         :type escalations: alignak.objects.escalation.Escalations
         :param timeperiods: Timeperiods objects, used to get escalation period
@@ -1994,14 +1995,14 @@ def is_escalable(self, notif, escalations, timeperiods):
 
         # We search since when we are in notification for escalations
         # that are based on time
-        in_notif_time = time.time() - notif.creation_time
+        in_notif_time = time.time() - notification.creation_time
 
         # Check is an escalation match the current_notification_number
-        for escal_id in self.escalations:
-            escal = escalations[escal_id]
-            escal_period = timeperiods[escal.escalation_period]
-            if escal.is_eligible(notif.t_to_go, self.state, notif.notif_nb,
-                                 in_notif_time, cls.interval_length, escal_period):
+        for escalation_id in self.escalations:
+            escalation = escalations[escalation_id]
+            escalation_period = timeperiods[escalation.escalation_period]
+            if escalation.is_eligible(notification.t_to_go, self.state, notification.notif_nb,
+                                      in_notif_time, cls.interval_length, escalation_period):
                 return True
 
         return False
@@ -2030,14 +2031,14 @@ def get_next_notification_time(self, notif, escalations, timeperiods):
         # and then look for currently active notifications, and take notification_interval
         # if filled and less than the self value
         in_notif_time = time.time() - notif.creation_time
-        for escal_id in self.escalations:
-            escal = escalations[escal_id]
-            escal_period = timeperiods[escal.escalation_period]
-            if escal.is_eligible(notif.t_to_go, self.state, notif.notif_nb,
-                                 in_notif_time, cls.interval_length, escal_period):
-                if escal.notification_interval != -1 and \
-                        escal.notification_interval < notification_interval:
-                    notification_interval = escal.notification_interval
+        for escalation_id in self.escalations:
+            escalation = escalations[escalation_id]
+            escalation_period = timeperiods[escalation.escalation_period]
+            if escalation.is_eligible(notif.t_to_go, self.state, notif.notif_nb,
+                                 in_notif_time, cls.interval_length, escalation_period):
+                if escalation.notification_interval != -1 and \
+                        escalation.notification_interval < notification_interval:
+                    notification_interval = escalation.notification_interval
 
         # So take the by default time
         std_time = notif.t_to_go + notification_interval * cls.interval_length
@@ -2054,25 +2055,26 @@ def get_next_notification_time(self, notif, escalations, timeperiods):
         creation_time = notif.creation_time
         in_notif_time = now - notif.creation_time
 
-        for escal_id in self.escalations:
-            escal = escalations[escal_id]
+        for escalation_id in self.escalations:
+            escalation = escalations[escalation_id]
             # If the escalation was already raised, we do not look for a new "early start"
-            if escal.get_name() not in notif.already_start_escalations:
-                escal_period = timeperiods[escal.escalation_period]
-                next_t = escal.get_next_notif_time(std_time, self.state,
-                                                   creation_time, cls.interval_length, escal_period)
+            if escalation.get_name() not in notif.already_start_escalations:
+                escalation_period = timeperiods[escalation.escalation_period]
+                next_t = escalation.get_next_notif_time(std_time, self.state,
+                                                        creation_time, cls.interval_length,
+                                                        escalation_period)
                 # If we got a real result (time base escalation), we add it
                 if next_t is not None and now < next_t < res:
                     res = next_t
 
         # And we take the minimum of this result. Can be standard or escalation asked
         return res
 
-    def get_escalable_contacts(self, notif, escalations, timeperiods):
+    def get_escalable_contacts(self, notification, escalations, timeperiods):
         """Get all contacts (uniq) from eligible escalations
 
-        :param notif: Notification to get data from (notif number...)
-        :type notif: alignak.objects.notification.Notification
+        :param notification: Notification to get data from (notif number...)
+        :type notification: alignak.objects.notification.Notification
         :param escalations: Esclations objects, used to get escalation objects (contact, period)
         :type escalations: alignak.objects.escalation.Escalations
         :param timeperiods: Timeperiods objects, used to get escalation period
@@ -2085,17 +2087,18 @@ def get_escalable_contacts(self, notif, escalations, timeperiods):
 
         # We search since when we are in notification for escalations
         # that are based on this time
-        in_notif_time = time.time() - notif.creation_time
+        in_notif_time = time.time() - notification.creation_time
 
         contacts = set()
-        for escal_id in self.escalations:
-            escal = escalations[escal_id]
-            escal_period = timeperiods[escal.escalation_period]
-            if escal.is_eligible(notif.t_to_go, self.state, notif.notif_nb,
-                                 in_notif_time, cls.interval_length, escal_period):
-                contacts.update(escal.contacts)
+        for escalation_id in self.escalations:
+            escalation = escalations[escalation_id]
+
+            escalation_period = timeperiods[escalation.escalation_period]
+            if escalation.is_eligible(notification.t_to_go, self.state, notification.notif_nb,
+                                      in_notif_time, cls.interval_length, escalation_period):
+                contacts.update(escalation.contacts)
                 # And we tag this escalations as started now
-                notif.already_start_escalations.add(escal.get_name())
+                notification.already_start_escalations.add(escalation.get_name())
 
         return list(contacts)
 
@@ -2219,55 +2222,59 @@ def scatter_notification(self, notif, contacts, notifways, timeperiods, macromod
         cls = self.__class__
         childnotifications = []
         escalated = False
-        notif_contacts = []
+        notification_contacts = []
         if notif.type == u'RECOVERY':
             if self.first_notification_delay != 0 and not self.notified_contacts:
                 # Recovered during first_notification_delay. No notifications
                 # have been sent yet, so we keep quiet
-                notif_contacts = []
+                notification_contacts = []
             else:
                 # The old way. Only send recover notifications to those contacts
                 # who also got problem notifications
-                notif_contacts = [c_id for c_id in self.notified_contacts]
+                notification_contacts = [c_id for c_id in self.notified_contacts]
             self.notified_contacts.clear()
         else:
             # Check is an escalation match. If yes, get all contacts from escalations
             if self.is_escalable(notif, escalations, timeperiods):
-                notif_contacts = self.get_escalable_contacts(notif, escalations, timeperiods)
+                notification_contacts = self.get_escalable_contacts(notif, escalations, timeperiods)
                 escalated = True
             # else take normal contacts
             else:
                 # notif_contacts = [contacts[c_id] for c_id in self.contacts]
-                notif_contacts = self.contacts
+                notification_contacts = self.contacts
 
-        for contact_id in notif_contacts:
-            contact = contacts[contact_id]
+        recipients = []
+        recipients_names = []
+        for contact_uuid in notification_contacts:
             # We do not want to notify again a contact with notification interval == 0
             # if has been already notified except if the item hard state changed!
             # This can happen when a service exits a downtime and it is still in
             # critical/warning (and not acknowledge)
-            if notif.type == u'PROBLEM' and \
-                    self.notification_interval == 0 \
+            if notif.type == u'PROBLEM' and self.notification_interval == 0 \
                     and self.state_type == 'HARD' and self.last_state_type == self.state_type \
                     and self.state == self.last_state \
                     and contact.uuid in self.notified_contacts:
                 # Do not send notification
                 continue
+            recipients.append(contact_uuid)
+            recipients_names.append(contacts[contact_uuid].contact_name)
+
+        for contact_uuid in recipients:
+            contact = contacts[contact_uuid]
+
             # Get the property name for notification commands, like
             # service_notification_commands for service
             notif_commands = contact.get_notification_commands(notifways, cls.my_type)
 
             for cmd in notif_commands:
-                # Get the notification recipients list
-                recipients = ','.join([contacts[c_uuid].contact_name for c_uuid in notif_contacts])
                 data = {
                     'type': notif.type,
                     'command': u'VOID',
                     'command_call': cmd,
                     'ref': self.uuid,
                     'contact': contact.uuid,
                     'contact_name': contact.contact_name,
-                    'recipients': recipients,
+                    'recipients': recipients_names,
                     't_to_go': notif.t_to_go,
                     'escalated': escalated,
                     'timeout': cls.notification_timeout,
@@ -2429,7 +2436,6 @@ def launch_check(self, timestamp, hosts, services, timeperiods,
             self.checks_in_progress.append(chk.uuid)
 
         self.update_in_checking()
-        print("Check: %s" % chk)
 
         # We need to put this new check in our actions queue
         # so scheduler can take it

alignak/objects/service.py

@@ -634,11 +634,9 @@ def raise_check_result(self):
         elif self.state == 'CRITICAL':
             log_level = 'error'
         brok = make_monitoring_log(
-            log_level, 'ACTIVE SERVICE CHECK: %s;%s;%s;%s;%d;%s' % (
-                self.host_name, self.get_name(),
-                self.state, self.state_type,
-                self.attempt, self.output
-            )
+            log_level, 'ACTIVE SERVICE CHECK: %s;%s;%s;%d;%s' % (self.host_name, self.get_name(),
+                                                                 self.state, self.attempt,
+                                                                 self.output)
         )
         self.broks.append(brok)
 
@@ -1116,16 +1114,12 @@ def is_blocking_notifications(self, notification_period, hosts, services, n_type
                 'n' in self.notification_options:
             logger.debug("Service: %s, notification %s sending is blocked by configuration",
                          self.get_name(), n_type)
-            print("Service: %s, notification %s sending is blocked by configuration"
-                  % (self.get_name(), n_type))
             return True
 
         # Does the notification period allow sending out this notification?
         if notification_period is not None and not notification_period.is_time_valid(t_wished):
             logger.debug("Service: %s, notification %s sending is blocked by globals",
                          self.get_name(), n_type)
-            print("Service: %s, notification %s sending is blocked by notification period"
-                  % (self.get_name(), n_type))
             return True
 
         if n_type in (u'PROBLEM', u'RECOVERY') and (

alignak/objects/serviceescalation.py

@@ -120,7 +120,7 @@ def explode(self, escalations):
             host_name = getattr(escalation, 'host_name', '')
             creation_dict = {
                 'escalation_name':
-                    'Generated-ServiceEscalation-%s-%s' % (host_name, escalation.uuid)
+                    'Generated-SE-%s-%s' % (host_name, escalation.uuid)
             }
             for prop in properties:
                 if hasattr(escalation, prop):