status_logger: send step results as well

scripts/master/status_logger.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.
 
 """Log status events to a file on disk or event collection endpoint."""
 
 
 import json
 import logging
 import logging.handlers
@@ skipping 165 matching lines @@
               '/ ts_mon_logging: %s' % (
               self._logging, self._event_logging, self._ts_mon_logging))
       else:
         self._configure({'file_logging': False,
                          'event_logging': False,
                          'ts_mon_logging': False})  # Reset to defaults.
 
       self._last_checked_active = now
     return self._active
 
-
   def send_build_result(
       self, scheduled, started, finished, builder_name, bot_name, result,
       project_id=None, subproject_tag=None, steps=None, pre_test_time_s=None):
     """Log a build result for ts_mon.
 
     This allows computing metrics for builds in mastermon.
     """
     d = {
         'timestamp_ms': finished * 1000,
         'builder': builder_name,
         'slave': bot_name,
         'result': result.lower(),
         'duration_s': finished - started,
         'pending_s': started - scheduled,
         'total_s': finished - scheduled,
     }
     if project_id:
       d['project_id'] = project_id
     if subproject_tag:
       d['subproject_tag'] = subproject_tag
     if steps:
       d['steps'] = steps
     if pre_test_time_s is not None:
       d['pre_test_time_s'] = pre_test_time_s
     self.ts_mon_logger.info(json.dumps(d))
 
+  def send_step_results(
+      self, timestamp, builder_name, bot_name,
+      step_result, project_id, subproject_tag):
+    """Log step results for ts_mon
+
+    Args:
+      timestamp(int): when the event was generated (end of a step). Seconds
+        since the Unix epoch.
+      builder_name(str): name of the builder the steps are part of.
+      bot_name(str): name of the machine running the build.
+      step_result (str): result for this step.
+      project_id(str): 'project' as shown on the codereview.
+      subproject_tag(str): a mention of a subproject. Mostly used to distinguish
+        between chromium and blink CLs in the chromium project.
+    """
+    # the presence of the field 'step_result' is how the collecting daemon

[Sergey Berezin, 2016/04/11 23:49:48]

nit: Capitalize the first word.

+    # tells the difference between this case and the one from send_build_result.
+    d = {
+      'timestamp': timestamp,
+      'builder': builder_name,
+      'step_result': step_result,
+      'slave': bot_name,
+      'project_id': project_id,
+      'subproject_tag': subproject_tag,
+    }
+    self.ts_mon_logger.info(json.dumps(d))
+
+
   def send_build_event(self, timestamp_kind, timestamp, build_event_type,
                        bot_name, builder_name, build_number, build_scheduled_ts,
                        step_name=None, step_number=None, result=None,
                        extra_result_code=None, patch_url=None):
     """Log a build/step event for event_mon."""
 
     if self.active and self._event_logging:
       # List options to pass to send_monitoring_event, without the --, to save
       # a bit of space.
       d = {'event-mon-timestamp-kind': timestamp_kind,
@@ skipping 260 matching lines @@
     self.log('stepFinished', '%s, %d, %s, %r',
              builder_name, build_number, step_name, results)
     _, finished = step.getTimes()
     self.send_build_event(
         'END', finished * 1000, 'STEP', bot, builder_name, build_number,
         self._get_requested_at_millis(build),
         step_name=step_name, step_number=step.step_number,
         result=buildbot.status.results.Results[results[0]],
         patch_url=self._get_patch_url(build.getProperties()))
 
+    # Send step result to ts-mon
+    properties = build.getProperties()
+    project_id = properties.getProperty('patch_project')
+    subproject_tag = properties.getProperty('subproject_tag')
+
+    self.send_step_results(
+      finished,
+      builder_name,
+      bot,
+      buildbot.status.results.Results[step.getResults()[0]],
+      project_id,
+      subproject_tag)
+
   def buildFinished(self, builderName, build, results):
     build_number = build.getNumber()
     bot = build.getSlavename()
     self.log('buildFinished', '%s, %d, %s, %r',
              builderName, build_number, bot, results)
     started, finished = build.getTimes()
 
     # Calculate when build was scheduled if possible. Use build started
     # timestamp as initial approximation.
     scheduled = started
@@ skipping 46 matching lines @@
         pre_test_time_s=pre_test_time_s)
 
   def builderRemoved(self, builderName):
     self.log('builderRemoved', '%s', builderName)
 
   def slaveConnected(self, slaveName):
     self.log('slaveConnected', '%s', slaveName)
 
   def slaveDisconnected(self, slaveName):
     self.log('slaveDisconnected', '%s', slaveName)