Refactor Standard Metrics (#724)

Author: lzchen

contrib/opencensus-ext-azure/README.rst

@@ -151,10 +151,10 @@ The exporter also includes a set of standard metrics that are exported to Azure
 
 Below is a list of standard metrics that are currently available:
 
-- Available memory (bytes)
+- Available Memory (bytes)
 - CPU Processor Time (percentage)
 - Process CPU Usage (percentage)
-- Process private bytes (bytes)
+- Process Private Bytes (bytes)
 
 Trace
 ~~~~~

contrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics.py

@@ -0,0 +1,52 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.metrics.export.gauge import Registry
+from opencensus.metrics.export.metric_producer import MetricProducer
+from opencensus.ext.azure.metrics_exporter.standard_metrics.cpu \
+    import ProcessorTimeMetric
+from opencensus.ext.azure.metrics_exporter.standard_metrics.memory \
+    import AvailableMemoryMetric
+from opencensus.ext.azure.metrics_exporter.standard_metrics.process \
+    import ProcessCPUMetric
+from opencensus.ext.azure.metrics_exporter.standard_metrics.process \
+    import ProcessMemoryMetric
+
+# List of standard metrics to track
+STANDARD_METRICS = [AvailableMemoryMetric, ProcessCPUMetric,
+                    ProcessMemoryMetric, ProcessorTimeMetric]
+
+
+def register_metrics():
+    registry = Registry()
+    for standard_metric in STANDARD_METRICS:
+        metric = standard_metric()
+        registry.add_gauge(metric())
+    return registry
+
+
+class AzureStandardMetricsProducer(MetricProducer):
+    """Implementation of the producer of standard metrics.
+
+    Includes Azure specific standard metrics, implemented
+    using gauges.
+    """
+    def __init__(self):
+        self.registry = register_metrics()
+
+    def get_metrics(self):
+        return self.registry.get_metrics()
+
+
+producer = AzureStandardMetricsProducer()

contrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics/__init__.py

@@ -0,0 +1,49 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import psutil
+
+from opencensus.metrics.export.gauge import DerivedDoubleGauge
+
+
+class ProcessorTimeMetric(object):
+    NAME = "\\Processor(_Total)\\% Processor Time"
+    @staticmethod
+    def get_value():
+        cpu_times_percent = psutil.cpu_times_percent()
+        return 100 - cpu_times_percent.idle
+
+    def __call__(self):
+        """ Returns a derived gauge for the processor time.
+
+        Processor time is defined as a float representing the current system
+        wide CPU utilization minus idle CPU time as a percentage. Idle CPU
+        time is defined as the time spent doing nothing. Return values range
+        from 0.0 to 100.0 inclusive.
+
+        :rtype: :class:`opencensus.metrics.export.gauge.DerivedDoubleGauge`
+        :return: The gauge representing the processor time metric
+        """
+        gauge = DerivedDoubleGauge(
+            ProcessorTimeMetric.NAME,
+            'Processor time as a percentage',
+            'percentage',
+            [])
+        gauge.create_default_time_series(ProcessorTimeMetric.get_value)
+        # From the psutil docs: the first time this method is called with
+        # interval = None it will return a meaningless 0.0 value which you are
+        # supposed to ignore. Call cpu_percent() once so that the subsequent
+        # calls from the gauge will be meaningful.
+        psutil.cpu_times_percent()
+        return gauge

contrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics/cpu.py

@@ -0,0 +1,41 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import psutil
+
+from opencensus.metrics.export.gauge import DerivedLongGauge
+
+
+class AvailableMemoryMetric(object):
+    NAME = "\\Memory\\Available Bytes"
+    @staticmethod
+    def get_value():
+        return psutil.virtual_memory().available
+
+    def __call__(self):
+        """ Returns a derived gauge for available memory
+
+        Available memory is defined as memory that can be given instantly to
+        processes without the system going into swap.
+
+        :rtype: :class:`opencensus.metrics.export.gauge.DerivedLongGauge`
+        :return: The gauge representing the available memory metric
+        """
+        gauge = DerivedLongGauge(
+            AvailableMemoryMetric.NAME,
+            'Amount of available memory in bytes',
+            'byte',
+            [])
+        gauge.create_default_time_series(AvailableMemoryMetric.get_value)
+        return gauge