event_mon: support for GomaStats

infra_libs/event_mon/monitoring.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.
 
 import logging
 
 from google.protobuf.message import DecodeError
 from infra_libs.event_mon.protos.chrome_infra_log_pb2 import (
   ChromeInfraEvent, ServiceEvent, BuildEvent)
 from infra_libs.event_mon.protos.goma_stats_pb2 import GomaStats
 from infra_libs.event_mon.protos.log_request_lite_pb2 import LogRequestLite
 from infra_libs.event_mon import config, router
 
 
 # These constants are part of the API.
 EVENT_TYPES = ('START', 'STOP', 'UPDATE', 'CURRENT_VERSION', 'CRASH')
 BUILD_EVENT_TYPES = ('SCHEDULER', 'BUILD', 'STEP')
-BUILD_RESULTS = (None, 'UNKNOWN', 'SUCCESS', 'FAILURE', 'INFRA_FAILURE',
+BUILD_RESULTS = ('UNKNOWN', 'SUCCESS', 'FAILURE', 'INFRA_FAILURE',
                  'WARNING', 'SKIPPED', 'RETRY')
-TIMESTAMP_KINDS = (None, 'UNKNOWN', 'POINT', 'BEGIN', 'END')
+TIMESTAMP_KINDS = ('UNKNOWN', 'POINT', 'BEGIN', 'END')
 
 # Maximum size of stack trace sent in an event, in characters.
 STACK_TRACE_MAX_SIZE = 1000
 
 
 class Event(object):
   """Wraps the event proto with the necessary boilerplate code."""
 
   def __init__(self, timestamp_kind='POINT',
                event_timestamp_ms=None, service_name=None):
@@ skipping 48 matching lines @@
 
   The proto is filled using values provided in setup_monitoring() at
   initialization time, and args.
 
   Args:
     timestamp_kind (string): any of ('POINT', 'BEGIN', 'END').
 
   Returns:
     event (chrome_infra_log_pb2.ChromeInfraEvent):
   """
-  if timestamp_kind not in TIMESTAMP_KINDS:
+  # Testing for None because we want an error message when timestamp_kind == ''.
+  if timestamp_kind is not None and timestamp_kind not in TIMESTAMP_KINDS:
     logging.error('Invalid value for timestamp_kind: %s', timestamp_kind)
     return None
 
   # We must accept unicode here.
   if service_name is not None and not isinstance(service_name, basestring):
     logging.error('Invalid type for service_name: %s', type(service_name))
     return None
 
   event = ChromeInfraEvent()
   event.CopyFrom(config._cache['default_event'])
@@ skipping 147 matching lines @@
                     hostname,
                     build_name,
                     build_number=None,
                     build_scheduling_time=None,
                     step_name=None,
                     step_number=None,
                     result=None,
                     extra_result_code=None,
                     timestamp_kind='POINT',
                     event_timestamp=None,
-                    service_name=None):
+                    service_name=None,
+                    goma_stats=None):
   """Compute a ChromeInfraEvent filled with a BuildEvent.
 
   Arguments are identical to those in send_build_event(), please refer
   to this docstring.
 
   Returns:
     event (log_request_lite_pb2.LogRequestLite.LogEventLite): can be None
       if there is a major processing issue.
+

[Yoshisato Yanagisawa, 2015/10/29 02:42:52]

nit: unnecessary space?

   """
   if event_type not in BUILD_EVENT_TYPES:
     logging.error('Invalid value for event_type: %s', event_type)
     return Event.null()
 
   event_wrapper = Event(timestamp_kind, event_timestamp,
                         service_name=service_name)
   if event_wrapper.is_null:
     return event_wrapper
 
@@ skipping 53 matching lines @@
                     step_number)
 
   if step_number is not None:
     event.build_event.step_number = step_number
 
   # TODO(pgervais) remove this.
   # Hack to work around errors in the proto
   mapping = {'WARNINGS': 'WARNING', 'EXCEPTION': 'INFRA_FAILURE'}
   result = mapping.get(result, result)
 
-  if result not in BUILD_RESULTS:
-    logging.error('Invalid value for result: %s', result)
-  else:
-    if result:  # can be None
+  if result is not None:  # we want an error message if result==''.
+    if result not in BUILD_RESULTS:
+      logging.error('Invalid value for result: %s', result)
+    else:
       event.build_event.result = getattr(BuildEvent, result)
 
       if event_type == 'SCHEDULER':
         logging.error('A result was provided for a "SCHEDULER" event type '
                       '(%s). This is only accepted for BUILD and TEST types.',
                       result)
 
   if isinstance(extra_result_code, basestring):
     extra_result_code = (extra_result_code, )
   if not isinstance(extra_result_code, (list, tuple)):
     if extra_result_code is not None:
       logging.error('extra_result_code must be a string or list of strings. '
                     'Got %s' % type(extra_result_code))
   else:
     non_strings = []
     extra_result_strings = []
     for s in extra_result_code:
       if not isinstance(s, basestring):
         non_strings.append(s)
       else:
         extra_result_strings.append(s)
 
     if non_strings:
       logging.error('some values provided to extra_result_code are not strings:'
                     ' %s' % str(non_strings))
     for s in extra_result_strings:
       event.build_event.extra_result_code.append(s)
 
+  if goma_stats:
+    if isinstance(goma_stats, GomaStats):
+      event.build_event.goma_stats.MergeFrom(goma_stats)
+    else:
+      logging.error('expected goma_stats to be an instance of GomaStats, '
+                    'got %s', type(goma_stats))
+
   return event_wrapper
 
 
 def send_build_event(event_type,
                      hostname,
                      build_name,
                      build_number=None,
                      build_scheduling_time=None,
                      step_name=None,
                      step_number=None,
                      result=None,
                      extra_result_code=None,
                      timestamp_kind='POINT',
-                     event_timestamp=None):
+                     event_timestamp=None,
+                     goma_stats=None):
   """Send a ChromeInfraEvent filled with a BuildEvent
 
   Args:
     event_type (string): any name of enum BuildEvent.BuildEventType.
       (listed in infra_libs.event_mon.monitoring.BUILD_EVENT_TYPES)
     hostname (string): fqdn of the machine that is running the build / step.
       aka the bot name.
     build_name (string): name of the builder.
 
   Keyword args:
     build_number (int): as the name says.
     build_scheduling_time (int): timestamp telling when the build was
       scheduled. This is required when build_number is provided to make it
       possibly to distinguish two builds with the same build number.
     step_name (str): name of the step.
     step_number (int): rank of the step in the build. This is mandatory
       if step_name is provided, because step_name is not enough to tell the
       order.
     result (string): any name of enum BuildEvent.BuildResult.
       (listed in infra_libs.event_mon.monitoring.BUILD_RESULTS)
     extra_result_code (string or list of): arbitrary strings intended to provide
       more fine-grained information about the result.
+    goma_stats (goma_stats_pb2.GomaStats): statistics output by the Goma proxy.
 
   Returns:
     success (bool): False if some error happened.
   """
   return get_build_event(event_type,
                          hostname,
                          build_name,
                          build_number=build_number,
                          build_scheduling_time=build_scheduling_time,
                          step_name=step_name,
                          step_number=step_number,
                          result=result,
                          extra_result_code=extra_result_code,
                          timestamp_kind=timestamp_kind,
-                         event_timestamp=event_timestamp).send()
+                         event_timestamp=event_timestamp,
+                         goma_stats=goma_stats).send()
 
 
 def send_events(events):
   """Send several events at once to the endpoint.
 
   Args:
     events (iterable of Event): events to send
 
   Return:
     success (bool): True if data was successfully received by the endpoint.
   """
   return config._router.push_event(tuple(e.log_event() for e in events))