def testGetDiagnosticClassForName(self): cls0 = all_diagnostics.GetDiagnosticClassForName('GenericSet') gs0 = cls0(['foo']) gs0_dict = gs0.AsDict() # Run twice to ensure that the memoization isn't broken. cls1 = all_diagnostics.GetDiagnosticClassForName('GenericSet') gs1 = cls1(['foo']) gs1_dict = gs1.AsDict() self.assertEqual(gs0_dict['type'], 'GenericSet') self.assertEqual(gs1_dict['type'], 'GenericSet')
def _UpdateDiagnostics(self): """ Benchmarks that add histograms but don't use timeline_base_measurement need to add shared diagnostics separately. Make them available on the telemetry info.""" for name, value in self.AsDict().items(): if name in self.diagnostics: # If it is of type name, description or start time don't create new if name in [ reserved_infos.BENCHMARKS.name, reserved_infos.BENCHMARK_START.name, reserved_infos.BENCHMARK_DESCRIPTIONS.name ]: continue else: # this a stale value from the last run, remove it. del self.diagnostics[name] if isinstance(value, list): keep = False for val in value: if val: keep = True if not keep: continue else: if value is None: continue name_type = reserved_infos.GetTypeForName(name) diag_class = all_diagnostics.GetDiagnosticClassForName(name_type) diag = diag_class(value) self.diagnostics[name] = diag
def _GetDiagnostics(self): """Get benchmark and current story details as histogram diagnostics.""" diag_values = [ (reserved_infos.BENCHMARKS, self.benchmark_name), (reserved_infos.BENCHMARK_START, self.benchmark_start_us), (reserved_infos.BENCHMARK_DESCRIPTIONS, self.benchmark_description), (reserved_infos.LABELS, self.label), (reserved_infos.HAD_FAILURES, self.current_story_run.failed), (reserved_infos.STORIES, self.current_story.name), (reserved_infos.STORY_TAGS, self.current_story.GetStoryTagsList()), (reserved_infos.STORYSET_REPEATS, self.current_story_run.index), (reserved_infos.TRACE_START, self.current_story_run.start_us), ] diags = {} for diag, value in diag_values: if value is None or value == []: continue if diag.type == 'GenericSet' and not isinstance(value, list): value = [value] elif diag.type == 'DateRange': # We store timestamps in microseconds, DateRange expects milliseconds. value = value / 1e3 # pylint: disable=redefined-variable-type diag_class = all_diagnostics.GetDiagnosticClassForName(diag.type) diags[diag.name] = diag_class(value) return diags
def _GetDiagnostics(self): """Get benchmark metadata as histogram diagnostics.""" info = self._telemetry_info diag_values = [ (reserved_infos.BENCHMARKS, info.benchmark_name), (reserved_infos.BENCHMARK_START, info.benchmark_start_us), (reserved_infos.BENCHMARK_DESCRIPTIONS, info.benchmark_descriptions), (reserved_infos.LABELS, info.label), (reserved_infos.HAD_FAILURES, info.had_failures), (reserved_infos.STORIES, info._story_name), (reserved_infos.STORY_TAGS, info.GetStoryTagsList()), (reserved_infos.STORYSET_REPEATS, info.storyset_repeat_counter), (reserved_infos.TRACE_START, info.trace_start_us), (reserved_infos.TRACE_URLS, info.trace_url) ] diags = {} for diag, value in diag_values: if value is None or value == []: continue if diag.type == 'GenericSet' and not isinstance(value, list): value = [value] elif diag.type == 'DateRange': # We store timestamps in microseconds, DateRange expects milliseconds. value = value / 1e3 # pylint: disable=redefined-variable-type diag_class = all_diagnostics.GetDiagnosticClassForName(diag.type) diags[diag.name] = diag_class(value) return diags
def FromDict(dct): cls = all_diagnostics.GetDiagnosticClassForName(dct['type']) if not cls: raise ValueError('Unrecognized diagnostic type: ' + dct['type']) diagnostic = cls.FromDict(dct) if 'guid' in dct: diagnostic.guid = dct['guid'] return diagnostic
def assertHasDiagnostic(self, hist, diag_info, value=None): """Assert that a histogram is associated with the given diagnostic.""" self.assertIn(diag_info.name, hist.diagnostics) diag = hist.diagnostics[diag_info.name] self.assertIsInstance( diag, all_diagnostics.GetDiagnosticClassForName(diag_info.type)) if value is not None: # Assume we expect singleton GenericSet with the given value. self.assertEqual(len(diag), 1) self.assertEqual(next(iter(diag)), value)
def SetDiagnosticsValue(info, value): if value is None or value == []: return if info.type == 'GenericSet' and not isinstance(value, list): value = [value] elif info.type == 'DateRange': # We store timestamps in microseconds, DateRange expects milliseconds. value = value / 1e3 diag_class = all_diagnostics.GetDiagnosticClassForName(info.type) self.diagnostics[info.name] = diag_class(value)
def FromProto(d): # Here we figure out which field is set and downcast to the right diagnostic # type. The diagnostic names in the proto must be the same as the class # names in the python code, for instance Breakdown. attr_name = d.WhichOneof('diagnostic_oneof') assert attr_name, 'The diagnostic oneof cannot be empty.' d = getattr(d, attr_name) assert type(d).__name__ in all_diagnostics.GetDiagnosticTypenames(), ( 'Unrecognized diagnostic type ' + type(d).__name__) diag_type = type(d).__name__ cls = all_diagnostics.GetDiagnosticClassForName(diag_type) return cls.FromProto(d)
def _WrapDiagnostics(info_value_pairs): """Wrap diagnostic values in corresponding Diagnostics classes. Args: info_value_pairs: any iterable of pairs (info, value), where info is one of reserved infos defined in tracing.value.diagnostics.reserved_infos, and value can be any json-serializable object. Returns: An iterator over pairs (diagnostic name, diagnostic value). """ for info, value in info_value_pairs: if value is None or value == []: continue if info.type == 'GenericSet' and not isinstance(value, list): value = [value] diag_class = all_diagnostics.GetDiagnosticClassForName(info.type) yield info.name, diag_class(value)
def Deserialize(type_name, data, deserializer): cls = all_diagnostics.GetDiagnosticClassForName(type_name) if not cls: raise ValueError('Unrecognized diagnostic type: ' + type_name) return cls.Deserialize(data, deserializer)
def testEqualityForSmoke(self): for name in all_diagnostics.GetDiagnosticTypenames(): ctor = all_diagnostics.GetDiagnosticClassForName(name) self.assertTrue(hasattr(ctor, '__eq__'))