Merge lp:~gmb/maas/fix-bug-1402237-1.7 into lp:maas/1.7

[Graham Binns]

When fetching the non-debug events for a node, fetch the non-debug EventTypes first and then query the Event table using 'WHERE type_id IN <non-debug-EventTypes>'.

Previously, this query was the default Django-generated one, which did an INNER JOIN between Event and EventType. The new version is significantly faster, because there's an index missing on EventType.level which makes things slow at scale.

[Raphaël Badin (rvb)]

Looks good. Couple of remarks below but nothing major.

[0]

Typo in the commit message: fecthing

[1]

Could you say in the commit message why we're using this trick instead of adding the index… and that the index is being added to trunk…?

review: Approve

=== modified file 'src/maasserver/views/nodes.py'
--- src/maasserver/views/nodes.py	2014-12-10 16:28:52 +0000
+++ src/maasserver/views/nodes.py	2014-12-18 13:51:39 +0000
@@ -81,7 +81,10 @@
     Tag,
     )
 from maasserver.models.config import Config
-from maasserver.models.event import Event
+from maasserver.models.event import (
+    Event,
+    EventType,
+    )
 from maasserver.models.nodeprobeddetails import get_single_probed_details
 from maasserver.node_action import ACTIONS_DICT
 from maasserver.node_constraint_filter_forms import (
@@ -238,17 +241,25 @@
         # Add event information to the generated node dictionary. We exclude
         # debug after we calculate the count, so we show the correct total
         # number of events.
-        events = Event.objects.filter(node=node)
-        total_num_events = events.count()
-        events = events.exclude(type__level=logging.DEBUG).order_by('-id')
-        events_count = events.count()
+        node_events = Event.objects.filter(node=node)
+        total_num_events = node_events.count()
+
+        # We fetch the IDs of the EventTypes that are non-DEBUG here
+        # because in MAAS 1.7 the EventType.level field is missing an
+        # index. That makes querying for Events whose EventType has a
+        # non-DEBUG level (using an INNER JOIN) slow at scale. Doing it
+        # this way speeds things up considerably.
+        non_debug_event_type_ids = EventType.objects.exclude(
+            level=logging.DEBUG).values_list('id', flat=True)
+        non_debug_events = node_events.filter(
+            type__id__in=non_debug_event_type_ids).order_by('-id')
         if event_log_count > 0:
             # Limit the number of events.
-            events = events.all()[:event_log_count]
-            events_count = len(events)
+            events = non_debug_events.all()[:event_log_count]
+            displayed_events_count = len(events)
         node_dict['events'] = dict(
             total=total_num_events,
-            count=events_count,
+            count=displayed_events_count,
             events=[event_to_dict(event) for event in events],
             more_url=reverse('node-event-list-view', args=[node.system_id]),
             )

=== modified file 'src/maasserver/views/tests/test_nodes.py'
--- src/maasserver/views/tests/test_nodes.py	2014-12-15 10:04:18 +0000
+++ src/maasserver/views/tests/test_nodes.py	2014-12-18 13:51:39 +0000
@@ -164,6 +164,16 @@
             dict_node['events']['more_url'],
             Equals(reverse('node-event-list-view', args=[node.system_id])))
 
+    def test_node_to_dict_excludes_debug_events(self):
+        node = factory.make_Node()
+        debug_type = factory.make_EventType(level=logging.DEBUG)
+        debug_event = factory.make_Event(node, debug_type)
+
+        node_dict = node_to_dict(node, event_log_count=2)
+        self.assertThat(
+            [event_dict['id'] for event_dict in node_dict['events']['events']],
+            Not(Contains(debug_event.id)))
+
     def test_event_to_dict_keys(self):
         event = factory.make_Event()
         self.assertThat(