adding os metrics (os name and version) being collected every hour

infra/services/sysmon/system_metrics.py

 # Copyright (c) 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 errno
 import os
 import logging
+import platform
+import sys
 import time
 
 import psutil
 
 from infra_libs import ts_mon
 
 
 cpu_count = ts_mon.GaugeMetric('dev/cpu/count',
                                description='Number of CPU cores.')
 cpu_time = ts_mon.FloatMetric('dev/cpu/time',
@@ skipping 67 matching lines @@
                                       'in the system run queue.')
 
 # tsmon pipeline uses backend clocks when assigning timestamps to metric points.
 # By comparing point timestamp to the point value (i.e. time by machine's local
 # clock), we can potentially detect some anomalies (clock drift, unusually high
 # metrics pipeline delay, completely wrong clocks, etc).
 #
 # It is important to gather this metric right before the flush.
 unix_time = ts_mon.GaugeMetric('dev/unix_time',
                                description='Number of milliseconds since epoch '
-                                  'based on local machine clock.')
+                               'based on local machine clock.')
+
+os_name = ts_mon.StringMetric('proc/os/name',
+                              description='OS name on the machine ')
+
+os_version = ts_mon.StringMetric('proc/os/version',
+                                 description='OS version on the machine ')
+
+os_arch = ts_mon.StringMetric('proc/os/arch',
+                              description='OS architecture on this machine')
+
+python_arch = ts_mon.StringMetric('proc/python/arch',
+                                  description='python userland '
+                                  'architecture on this machine')
 
 
 def get_uptime():
   uptime.set(int(time.time() - START_TIME))
 
 
 def get_cpu_info():
   cpu_count.set(psutil.cpu_count())
 
   times = psutil.cpu_times_percent()
@@ skipping 62 matching lines @@
     for metric, counter_name in metric_counter_names:
       try:
         metric.set(getattr(counters, counter_name), fields=fields)
       except ts_mon.MonitoringDecreasingValueError as ex:  # pragma: no cover
         # This normally shouldn't happen, but might if the network driver module
         # is reloaded, so log an error and continue instead of raising an
         # exception.
         logging.error(str(ex))
 
 
+def get_os_info():
+  os_name_data    = ''
+  os_version_data = ''
+
+  os_name_data    = platform.system().lower()
+  if 'windows' in os_name_data:
+    os_name_data    = 'windows'
+    # os_release will be something like '7', 'vista', or 'xp'
+    os_version_data = platform.release()
+
+  elif 'linux' in os_name_data:
+    # will return something like ('Ubuntu', '14.04', 'trusty')
+    dist_info_data  = platform.dist()
+    os_name_data    = dist_info_data[0]
+    os_version_data = dist_info_data[1]
+
+  # on mac platform.system() reports 'darwin'
+  else:
+    # this tuple is only populated on mac systems
+    mac_ver_data    = platform.mac_ver()
+    # [0] will be '10.11.5' or similar on a valid mac or will be '' on a
+    # non-mac
+    os_version_data = mac_ver_data[0]
+    if os_version_data:
+      # we found a valid mac
+      os_name_data = 'mac'
+    else :
+      # not a mac, unable to find platform information, reset
+      os_name_data    = ''
+      os_version_data = ''
+
+  # normalize to lower case
+  os_name_data    = os_name_data.lower()
+  os_version_data = os_version_data.lower()
+
+  python_arch_data = '32'
+  if sys.maxsize > 2**32:
+    python_arch_data = '64'
+
+  # construct metrics
+  os_name.set(os_name_data)
+  os_version.set(os_version_data)
+  os_arch.set(platform.machine())
+  python_arch.set(python_arch_data)
+
+
+def clear_os_info():
+  os_name.reset()
+  os_version.reset()
+  os_arch.reset()
+  python_arch.reset()
+
+
 def get_proc_info():
   procs = psutil.pids()
   proc_count.set(len(procs))
 
   if os.name == 'posix':  # pragma: no cover
     try:
       avg1, avg5, avg15 = os.getloadavg()
     except OSError:  # pragma: no cover
       pass
     else:
       load_average.set(avg1, fields={'minutes': 1})
       load_average.set(avg5, fields={'minutes': 5})
       load_average.set(avg15, fields={'minutes': 15})
 
 
 def get_unix_time():
   unix_time.set(int(time.time() * 1000))