send_monitoring_event: support for default event and gomastats

infra/tools/send_monitoring_event/send_event.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 argparse
 import glob
 import logging
 import os
 import json
 import sys
 
 from infra_libs import event_mon
+from infra_libs import ts_mon
 import infra_libs.logs
-from infra_libs import ts_mon
 
+from infra_libs.event_mon.protos.log_request_lite_pb2 import LogRequestLite
+from infra_libs.event_mon.protos.chrome_infra_log_pb2 import ChromeInfraEvent
+from infra_libs.event_mon.protos.goma_stats_pb2 import GomaStats
 
 LOGGER = logging.getLogger(__name__)
 
 
 def get_arguments(argv):
   """Process command-line arguments.
 
   Args:
     argv (list of strings): sys.argv[1:]
   Returns:
@@ skipping 13 matching lines @@
                                      --service-event-stack-trace "<stack trace>"
 
     run.py infra.tools.send_monitoring_event --build-event-type=SCHEDULER \\
                                      --build-event-build-name=foo
                                      --build-event-hostname='bot.dns.name'
     """, formatter_class=argparse.RawTextHelpFormatter)
 
   # Common fields
   common_group = parser.add_argument_group('Common event options')
   common_group.add_argument('--event-mon-timestamp-kind',
-                            choices=[kind
-                                     for kind in event_mon.TIMESTAMP_KINDS
-                                     if kind],
-                            default='POINT',

[dsansome, 2015/10/29 23:17:33]

Should this still have the default?  If not remove the 'Default: %(default)s'
help text?

[pgervais, 2015/11/02 19:38:58]

Done.

+                            choices=event_mon.TIMESTAMP_KINDS,
                             help='General kind of event. This value is used '
                             'e.g. to\nautomatically compute durations between '
                             'START and STOP\nevents. Default: %(default)s')
   common_group.add_argument('--event-mon-event-timestamp', type=int,
                             help='Timestamp when the event was generated, as '
                             'number of\nmilliseconds since the Unix EPOCH.'
                             '\nDefaults to current time.')
 
   # Service event
   service_group = parser.add_argument_group('Service event options')
@@ skipping 51 matching lines @@
                            choices=event_mon.BUILD_RESULTS,
                            help='Result of build or step depending on '
                            'whether any \n--build-event-step-* options have '
                            'been provided or not.')
 
   build_group.add_argument('--build-event-extra-result-code',
                            help='Extra result code. String, comma-separated '
                            'list of strings or json-encoded list of string. '
                            'Each one must be less than 20 characters long.')
 
+  build_group.add_argument('--build-event-goma-stats-path',
+                           metavar='FILENAME',
+                           help='File containing a serialized GomaStats '
+                           'protobuf.')
+
   # Read events from file
   file_group = parser.add_argument_group('Read events from file')
   file_group.add_argument('--events-from-file',
                           metavar='FILENAME', nargs='*',
                           help='File containing events as json dict. This '
                           'option\nis incompatible with --build-event-type and'
                           '\n--service-event-type.\nSee '
                           'send_event.read_events_from_file for details\n'
-                          'on the format. This options can be passed multiple\n'
+                          'on the format. This option can be passed multiple\n'
                           'times, and wildcards can be used.')
   file_group.add_argument('--delete-file-when-sent',
                           action='store_true', default=False,
                           help='If all events read from a file have been '
                           'successfully\nsent to the endpoint, delete the '
-                          'file. By default\nfiles are kept.')
+                          'file. By default\nfiles are kept. This does not '
+                          'affect the file pointed to by '
+                          '--event-logrequest-path')
+
+  file_group.add_argument('--event-logrequest-path',
+                          metavar='FILENAME',
+                          help='File containing a serialized LogRequestLite'
+                          'proto, containing a single ChromeInfraEvent that '
+                          'will be used as the default event. Such a file can '
+                          'be generated by passing "file" to '
+                          '--event-mon-run-type.')
 
   ts_mon.add_argparse_options(parser)
   event_mon.add_argparse_options(parser)
   infra_libs.logs.add_argparse_options(parser)
 
   parser.set_defaults(
       ts_mon_flush='manual',
       ts_mon_target_type='task',
       ts_mon_task_service_name='send_monitoring_event',
       ts_mon_task_job_name='manual',
@@ skipping 17 matching lines @@
     extra_result_code = args.build_event_extra_result_code.strip()
     if extra_result_code.startswith('['):
       extra_result_code = json.loads(extra_result_code)
     elif ',' in extra_result_code:
       extra_result_code = extra_result_code.split(',')
     args.build_event_extra_result_code = extra_result_code
 
   return args
 
 
+def _process_logrequest_path(args):
+  """Sets the default event based on --event-logrequest-path.
+
+  This function raises exceptions because if the base event is wrong, then it's
+  not worth sending anything anyway.
+  """
+  if args.event_logrequest_path:
+    try:
+      with open(args.event_logrequest_path, 'rb') as f:
+        request = LogRequestLite.FromString(f.read())
+
+      if len(request.log_event) == 1:
+        default_event = ChromeInfraEvent.FromString(
+          request.log_event[0].source_extension)
+        # Assume that the content is sane because we don't want to duplicate
+        # any business logic here.
+        # TODO(pgervais): find a better solution.
+        event_mon.set_default_event(default_event)
+      else:
+        raise ValueError(
+          'Expected only one log_event in the LogRequestLite proto '
+          'pointed by --event-logrequest-path. Found %d in %s',
+          len(request.log_event), args.event_logrequest_path)
+    except Exception:
+      LOGGER.exception('Failure when reading/parsing file %s',
+                       args.event_logrequest_path)
+      raise
+
+  default_event = event_mon.get_default_event()
+
+  # When the default event is set using --event-logrequest-path, passing
+  # --build-event-type or --service-event-type is optional. These options
+  # still takes precedence but they must keep the event type the same.
+  if (default_event.build_event.HasField('type') and
+      default_event.service_event.HasField('type')):
+    msg = ('Default event contains both service_event_type and '
+           'build_event_type which is incorrect. Make sure you passed '
+           'a correct proto to --event-logrequest-path. Otherwise it\'s an '
+           'internal error. Aborting.')
+    LOGGER.error(msg)
+    raise ValueError(msg)
+
+  if default_event.build_event.HasField('type'):
+    if args.service_event_type:
+      msg = ('The default event contains a type for build_event, but a '
+             'service_event type was provided on the command-line. At most '
+             'one of them can be specified. Aborting.')
+      LOGGER.error(msg)
+      raise ValueError(msg)
+
+    if not args.build_event_type:
+      args.build_event_type = event_mon.BuildEvent.BuildEventType.Name(
+        default_event.build_event.type)
+
+  if default_event.service_event.HasField('type'):
+    if args.build_event_type:
+      msg = ('The default event contains a type for service_event, but a '
+             'build_event type was provided on the command-line. At most '
+             'one of them can be specified. Aborting.')
+      LOGGER.error(msg)
+      raise ValueError(msg)
+    if not args.service_event_type:
+      args.service_event_type = event_mon.ServiceEvent.ServiceEventType.Name(
+        default_event.service_event.type)
+
+
 def process_argparse_options(args):  # pragma: no cover
   infra_libs.logs.process_argparse_options(args)
   event_mon.process_argparse_options(args)
+  # Put here because we want to send the presence metric as late as possible.
   ts_mon.process_argparse_options(args)
+  _process_logrequest_path(args)
 
 
 def send_service_event(args):
   """Entry point when --service-event-type is passed."""
   revinfo = {}
   if args.service_event_revinfo:
     if args.service_event_revinfo == '-':  # pragma: no cover
       revinfo = event_mon.parse_revinfo(sys.stdin.read())
     else:
       with open(args.service_event_revinfo, 'r') as f:
         revinfo = event_mon.parse_revinfo(f.read())
   elif args.service_event_revinfo_from_gclient:  # pragma: no cover
     revinfo = event_mon.get_revinfo()
 
   if args.service_event_stack_trace:
     args.service_event_type = 'CRASH'
 
   return bool(event_mon.send_service_event(
     args.service_event_type,
     code_version=revinfo.values(),
     stack_trace=args.service_event_stack_trace,
     timestamp_kind=args.event_mon_timestamp_kind,
     event_timestamp=args.event_mon_event_timestamp))
 
 
 def send_build_event(args):
   """Entry point when --build-event-type is passed."""
+  goma_stats = None
+  if args.build_event_goma_stats_path:
+    try:
+      with open(args.build_event_goma_stats_path, 'rb') as f:
+        goma_stats = GomaStats.FromString(f.read())
+    except Exception:
+      LOGGER.exception('Failure when reading/parsing file %s',
+                       args.build_event_goma_stats_path)
+      raise
+
 
   return bool(event_mon.send_build_event(
     args.build_event_type,
     args.build_event_hostname,
     args.build_event_build_name,
     build_number=args.build_event_build_number,
     build_scheduling_time=args.build_event_build_scheduling_time,
     step_name=args.build_event_step_name,
     step_number=args.build_event_step_number,
     result=args.build_event_result,
     extra_result_code=args.build_event_extra_result_code,
     timestamp_kind=args.event_mon_timestamp_kind,
-    event_timestamp=args.event_mon_event_timestamp))
+    event_timestamp=args.event_mon_event_timestamp,
+    goma_stats=goma_stats))
 
 
 def send_events_from_file(args):
   """Entry point when --events-from-file is passed."""
   file_list = get_event_file_list(args.events_from_file)
   status = True
 
   for filename in file_list:
     LOGGER.info('Processing %s', filename)
     events = read_events_from_file(filename)
@@ skipping 60 matching lines @@
             build_scheduling_time=args.get('build-event-build-scheduling-time'),
             step_name=args.get('build-event-step-name'),
             step_number=args.get('build-event-step-number'),
             result=args.get('build-event-result'),
             extra_result_code=args.get('build-event-extra-result-code'),
             timestamp_kind=args.get('event-mon-timestamp-kind'),
             event_timestamp=args.get('event-mon-event-timestamp'),
             service_name=args.get('event-mon-service-name')))
 
   return events