code: def assert_records_equal_nonvolatile(first, second, volatile_fields, indent=0):
    
    if isinstance(first, dict) and isinstance(second, dict):
      if set(first) != set(second):
        logging.error('%sMismatching keys:', ' ' * indent)
        logging.error('%s  %s', ' ' * indent, list(first.keys()))
        logging.error('%s  %s', ' ' * indent, list(second.keys()))
        assert set(first) == set(second)
      for key in first:
        if key in volatile_fields:
          continue
        try:
          assert_records_equal_nonvolatile(first[key], second[key],
                                           volatile_fields, indent + 2)
        except AssertionError:
          logging.error('%sKey: %s ^', ' ' * indent, key)
          raise
    elif hasattr(first, '_asdict') and hasattr(second, '_asdict'):
      # Compare namedtuples as dicts so we get more useful output.
      assert_records_equal_nonvolatile(first._asdict(), second._asdict(),
                                       volatile_fields, indent)
    elif hasattr(first, '__iter__') and hasattr(second, '__iter__'):
      for idx, (fir, sec) in enumerate(itertools.izip(first, second)):
        try:
          assert_records_equal_nonvolatile(fir, sec, volatile_fields, indent + 2)
        except AssertionError:
          logging.error('%sIndex: %s ^', ' ' * indent, idx)
          raise
    elif (isinstance(first, records.RecordClass) and
          isinstance(second, records.RecordClass)):
      assert_records_equal_nonvolatile(
          {slot: getattr(first, slot) for slot in first.__slots__},
          {slot: getattr(second, slot) for slot in second.__slots__},
          volatile_fields, indent)
    elif first != second:
      logging.error('%sRaw: "%s" != "%s"', ' ' * indent, first, second)
      assert first == second
docs: Compare two test_record tuples, ignoring any volatile fields.
  
    'Volatile' fields include any fields that are expected to differ between
    successive runs of the same test, mainly timestamps.  All other fields
    are recursively compared.