Implement Timeline Based Measurement v2

telemetry/telemetry/value/__init__.py

 # Copyright 2014 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.
 """
 The Value hierarchy provides a way of representing the values measurements
 produce such that they can be merged across runs, grouped by page, and output
 to different targets.
 
 The core Value concept provides the basic functionality:
 - association with a page, may be none
@@ skipping 25 matching lines @@
 # but there you have it. There are three contexts in which Values are converted
 # for use by buildbot, represented by these output-intent values.
 PER_PAGE_RESULT_OUTPUT_CONTEXT = 'per-page-result-output-context'
 COMPUTED_PER_PAGE_SUMMARY_OUTPUT_CONTEXT = 'merged-pages-result-output-context'
 SUMMARY_RESULT_OUTPUT_CONTEXT = 'summary-result-output-context'
 
 class Value(object):
   """An abstract value produced by a telemetry page test.
   """
   def __init__(self, page, name, units, important, description,
-               tir_label):
+               tir_label, grouping_keys):
     """A generic Value object.
 
     Args:
       page: A Page object, may be given as None to indicate that the value
           represents results for multiple pages.
       name: A value name string, may contain a dot. Values from the same test
           with the same prefix before the dot may be considered to belong to
           the same chart.
       units: A units string.
       important: Whether the value is "important". Causes the value to appear
           by default in downstream UIs.
       description: A string explaining in human-understandable terms what this
           value represents.
       tir_label: The string label of the TimelineInteractionRecord with
           which this value is associated.
+      grouping_keys: A dict that maps grouping key names to grouping keys.
     """
     # TODO(eakuefner): Check story here after migration (crbug.com/442036)
     if not isinstance(name, basestring):
       raise ValueError('name field of Value must be string.')
     if not isinstance(units, basestring):
       raise ValueError('units field of Value must be string.')
     if not isinstance(important, bool):
       raise ValueError('important field of Value must be bool.')
     if not ((description is None) or isinstance(description, basestring)):
       raise ValueError('description field of Value must absent or string.')
     if not ((tir_label is None) or
             isinstance(tir_label, basestring)):
       raise ValueError('tir_label field of Value must absent or '
                        'string.')
+    if not ((grouping_keys is None) or isinstance(grouping_keys, dict)):
+      raise ValueError('grouping_keys field of Value must be absent or dict')
+
+    if grouping_keys is None:
+      grouping_keys = {}
 
     self.page = page
     self.name = name
     self.units = units
     self.important = important
     self.description = description
     self.tir_label = tir_label
+    self.grouping_keys = grouping_keys
 
   def __eq__(self, other):
     return hash(self) == hash(other)
 
   def __hash__(self):
     return hash(str(self))
 
   def IsMergableWith(self, that):
     return (self.units == that.units and
             type(self) == type(that) and
@@ skipping 111 matching lines @@
 
     if self.description:
       d['description'] = self.description
 
     if self.tir_label:
       d['tir_label'] = self.tir_label
 
     if self.page:
       d['page_id'] = self.page.id
 
+    if self.grouping_keys:
+      d['grouping_keys'] = self.grouping_keys
+
     return d
 
   def AsDictWithoutBaseClassEntries(self):
     full_dict = self.AsDict()
     base_dict_keys = set(self._AsDictImpl().keys())
 
     # Extracts only entries added by the subclass.
     return dict([(k, v) for (k, v) in full_dict.iteritems()
                   if k not in base_dict_keys])
 
@@ skipping 69 matching lines @@
       d['page'] = None
 
     d['important'] = False
 
     tir_label = value_dict.get('tir_label', None)
     if tir_label:
       d['tir_label'] = tir_label
     else:
       d['tir_label'] = None
 
+    grouping_keys = value_dict.get('grouping_keys', None)
+    if grouping_keys:
+      d['grouping_keys'] = grouping_keys
+    else:
+      d['grouping_keys'] = None
+
     return d
 
 def ValueNameFromTraceAndChartName(trace_name, chart_name=None):
   """Mangles a trace name plus optional chart name into a standard string.
 
   A value might just be a bareword name, e.g. numPixels. In that case, its
   chart may be None.
 
   But, a value might also be intended for display with other values, in which
   case the chart name indicates that grouping. So, you might have
@@ skipping 14 matching lines @@
   whereas telemetry represents values with a chart_name.trace_name convention,
   where chart_name is optional. This convention is also used by chart_json.
 
   This converts from the telemetry convention to the buildbot convention,
   returning a 2-tuple (measurement_name, trace_name).
   """
   if '.' in value_name:
     return value_name.split('.', 1)
   else:
     return value_name, value_name