chromium-cq-status timeline view uses cname argument.

appengine/chromium_cq_status/handlers/patch_timeline_data.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Provides a JSON endpoint for CQ data as a series of Trace Viewer events.
 
 From the CQ data posted to the datastore, patch_timeline will construct a JSON
 object that can be parsed by Trace Viewer to create a timeline view.
 """
 
@@ skipping 25 matching lines @@
 
 def get_attempts(issue, patch): # pragma: no cover
   """Given an issue and a patch, returns a list of attempts.
 
   Returns a list of attempts. Attempts are lists of records which fall within
   the endpoints of patch_start and patch_stop actions, inclusive.
   """
   query = Record.query().order(Record.timestamp).filter(
     Record.tags == TAG_ISSUE % issue,
     Record.tags == TAG_PATCHSET % patch)
-  attempts = []
   attempt = None
   for record in query:
     action = record.fields.get('action')
     if attempt is None and action == 'patch_start':
       attempt = [record]
     # Sometimes CQ sends multiple patch_start in a single attempt. These
     # are ignored (only the first patch_start is kept).
     if attempt is not None and action != 'patch_start':
       attempt.append(record)
       if action == 'patch_stop':
-        attempts.append(attempt)
+        yield attempt
         attempt = None
   if attempt != None:
-    attempts.append(attempt)
-  return attempts
+    yield attempt
 
 
 def attempts_to_events(attempts): # pragma: no cover
   """Given a list of attempts, returns a list of Trace Viewer events.
 
   Attempts are a list of CQ records which fall between patch_start and
   patch_stop actions. Each record is converted to a Trace Viewer event
   of type 'B' or 'E', representing begin and end respectively.
 
   Occasinally CQ runs jobs without first a record representing a trigger
@@ skipping 58 matching lines @@
   patch_ready_to_commit: single 'B' event representing start of commit attempt
   patch_committed: single 'E' event representing successful commit
   patch_failed: single 'E' event representing completed patch attempt
   patch_stop: single 'E' event representing the end of the attempt.
   verifier_trigger: multiple 'B' events, one for each builder triggered.
   verifier_jobs_update: multiple 'E' events, one for each builder success
     or failure.
   """
   action = record.fields.get('action')
   attempt_string = 'Attempt %d' % attempt_number
+  timestamp = record.fields.get('timestamp')
   if action == 'verifier_trigger':
-    timestamp = record.fields['timestamp']
     masters = record.fields.get('trybots', {})
     for master in masters:
       for builder in masters[master]:
         yield TraceViewerEvent(builder, master, 'B', timestamp, attempt_string,
-                               builder)
+                               builder, 'cq_build_running')
   elif action == 'verifier_jobs_update':
     job_states = record.fields.get('jobs', {})
     # CQ splits jobs into lists based on their state.
     for cq_job_state, jobs in job_states.iteritems():
       # Jobs can be in many different states, JOB_STATE maps them to
       # 'running' or not.
       job_state = JOB_STATE.get(cq_job_state)
       if not job_state or job_state == 'running':
         continue
       for job_info in jobs:
         master = job_info['master']
         builder = job_info['builder']
         timestamp = rietveld_timestamp(job_info['timestamp'])
+        cname = 'cq_build_' + job_state
         args = {
           'build_url': job_info.get('url'),
-          'job_state': job_state,
         }
         yield TraceViewerEvent(builder, master, 'E', timestamp, attempt_string,
-                               builder, args)
+                               builder, cname, args)
   elif action == 'patch_start':
     yield TraceViewerEvent(attempt_string, 'Patch Progress', 'B',
-                           record.fields['timestamp'], attempt_string,
-                           'Patch Progress', {'job_state': 'attempt_running'})
+                           timestamp, attempt_string,
+                           'Patch Progress', 'cq_build_attempt_running')
   elif action == 'patch_ready_to_commit':
     yield TraceViewerEvent('Patch Committing', 'Patch Progress', 'B',
-                           record.fields['timestamp'], attempt_string,
-                           'Patch Progress', {'job_state': 'attempt_running'})
+                           timestamp, attempt_string,
+                           'Patch Progress', 'cq_build_attempt_running')
   elif action == 'patch_committed':
     yield TraceViewerEvent('Patch Committing', 'Patch Progress', 'E',
-                             record.fields['timestamp'], attempt_string,
-                             'Patch Progress', {'job_state': 'attempt_passed'})
+                             timestamp, attempt_string,
+                             'Patch Progress', 'cq_build_attempt_passed')
   elif action == 'patch_stop':
-    state = 'attempt_'
+    cname = 'cq_build_attempt_'
     if 'successfully committed' in record.fields['message']:
-      state += 'passed'
+      cname += 'passed'
     else:
-      state += 'failed'
+      cname += 'failed'
     yield TraceViewerEvent(attempt_string, 'Patch Progress', 'E',
-                           record.fields['timestamp'], attempt_string,
-                           'Patch Progress', {
-                               'job_state': state,
-                               'action': action,
-                           })
+                           timestamp, attempt_string, 'Patch Progress',
+                           cname, {'action': action})
 
 
 class TraceViewerEvent(): # pragma: no cover
   """A class used to create JSON objects corresponding to an event.
 
   Trace Viewer requires a specific set of fields, described below:
 
   name: the name of the event, displayed as a label on the interval
   cat: category of the event, used with the search functionality
   ph: type of event. for CQ data, it will be 'B' or 'E' for begin or end
   ts: timestamp of event
   pid: process id, used for grouping threads
   tid: thread id, displayed to the left of all intervals with the same thread
   """
-  def __init__(self, name, cat, ph, ts, pid, tid, args=None):
+  def __init__(self, name, cat, ph, ts, pid, tid, cname, args=None):
     self.name = name
     self.cat = cat
     self.ph = ph
     self.ts = ts
     self.pid = pid
     self.tid = tid
+    self.cname = cname
     self.args = args or {}
 
   def to_dict(self):
     return {
       'name': self.name,
       'cat': self.cat,
       'ph': self.ph,
       'ts': int(self.ts * 1000000),
       'pid': self.pid,
       'tid': self.tid,
+      'cname': self.cname,
       'args': self.args
     }
 
   def builder_key(self):
     """Returns an identifier for the build of the form master/builder."""
     return self.cat + '/' + self.name
 
 
 def rietveld_timestamp(timestamp_string): # pragma: no cover
   """Converts a Rietveld timestamp into a unix timestamp."""
   try:
     return to_unix_timestamp(
         datetime.strptime(timestamp_string, RIETVELD_TIMESTAMP_FORMAT))
   except ValueError:
     return None