Standard Metric - Private Bytes (#718)

Author: lzchen

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

@@ -12,15 +12,19 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
 import psutil
 
 from opencensus.metrics.export.gauge import DerivedLongGauge
 from opencensus.metrics.export.gauge import Registry
 from opencensus.metrics.export.metric_producer import MetricProducer
 
+logger = logging.getLogger(__name__)
+
 
 # Namespaces used in Azure Monitor
 AVAILABLE_MEMORY = "\\Memory\\Available Bytes"
+PRIVATE_BYTES = "\\Process(??APP_WIN32_PROC??)\\Private Bytes"
 
 
 def get_available_memory():
@@ -31,7 +35,7 @@ def get_available_memory_metric():
     """ 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
+    processes without the system going into swap.
 
     :rtype: :class:`opencensus.metrics.export.gauge.DerivedLongGauge`
     :return: The gauge representing the available memory metric
@@ -45,6 +49,32 @@ def get_available_memory_metric():
     return gauge
 
 
+def get_process_private_bytes():
+    try:
+        process = psutil.Process()
+        return process.memory_info().rss
+    except Exception:
+        logger.exception('Error handling get process private bytes.')
+
+
+def get_process_private_bytes_metric():
+    """ Returns a derived gauge for private bytes for the current process
+
+    Private bytes for the current process is measured by the Resident Set
+    Size, which is the non-swapped physical memory a process has used.
+
+    :rtype: :class:`opencensus.metrics.export.gauge.DerivedLongGauge`
+    :return: The gauge representing the private bytes metric
+    """
+    gauge = DerivedLongGauge(
+        PRIVATE_BYTES,
+        'Amount of memory process has used in bytes',
+        'byte',
+        [])
+    gauge.create_default_time_series(get_process_private_bytes)
+    return gauge
+
+
 class AzureStandardMetricsProducer(MetricProducer):
     """Implementation of the producer of standard metrics.
 
@@ -54,6 +84,7 @@ class AzureStandardMetricsProducer(MetricProducer):
     def __init__(self):
         self.registry = Registry()
         self.registry.add_gauge(get_available_memory_metric())
+        self.registry.add_gauge(get_process_private_bytes_metric())
 
     def get_metrics(self):
         return self.registry.get_metrics()

contrib/opencensus-ext-azure/tests/test_azure_standard_metrics.py

@@ -31,7 +31,7 @@ def test_producer_get_metrics(self):
         producer = standard_metrics.AzureStandardMetricsProducer()
         metrics = producer.get_metrics()
 
-        self.assertEqual(len(metrics), 1)
+        self.assertEqual(len(metrics), 2)
 
     def test_get_available_memory_metric(self):
         gauge = standard_metrics.get_available_memory_metric()
@@ -46,3 +46,30 @@ def test_get_available_memory(self, psutil_mock):
         mem = standard_metrics.get_available_memory()
 
         self.assertEqual(mem, 100)
+
+    def test_get_process_private_bytes_metric(self):
+        gauge = standard_metrics.get_process_private_bytes_metric()
+
+        # TODO: Refactor names to be platform generic
+        self.assertEqual(gauge.descriptor.name,
+                         '\\Process(??APP_WIN32_PROC??)\\Private Bytes')
+
+    def test_get_process_private_bytes(self):
+        with mock.patch('psutil.Process') as process_mock:
+            memory = collections.namedtuple('memory', 'rss')
+            pmem = memory(rss=100)
+            process = mock.Mock()
+            process.memory_info.return_value = pmem
+            process_mock.return_value = process
+            mem = standard_metrics.get_process_private_bytes()
+
+            self.assertEqual(mem, 100)
+
+    @mock.patch('opencensus.ext.azure.metrics_exporter'
+                '.standard_metrics.logger')
+    def test_get_process_private_bytes_exception(self, logger_mock):
+        with mock.patch('psutil.Process') as process_mock:
+            process_mock.side_effect = Exception()
+            standard_metrics.get_process_private_bytes()
+
+            logger_mock.exception.assert_called()