Standard Metrics - Incoming Requests Per Second (#758)

* Incoming requests for Python3

* python2 support

* change namespace

* add tests

* More tests

* Fix lint

* Fix lint

* Add test

* Add CHANGELOG

Author: lzchen

contrib/opencensus-ext-azure/CHANGELOG.md

@@ -1,6 +1,8 @@
 # Changelog
 
 ## Unreleased
+- Standard metrics incoming requests per second
+  ([#758](https://github.com/census-instrumentation/opencensus-python/pull/758))
 
 ## 0.7.0
 Released 2019-07-31

contrib/opencensus-ext-azure/README.rst

@@ -153,6 +153,7 @@ Below is a list of standard metrics that are currently available:
 
 - Available Memory (bytes)
 - CPU Processor Time (percentage)
+- Incoming Request Rate (per second)
 - Outgoing Request Rate (per second)
 - Process CPU Usage (percentage)
 - Process Private Bytes (bytes)

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

@@ -16,21 +16,24 @@
 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.dependency \
+from opencensus.ext.azure.metrics_exporter.standard_metrics.http_dependency \
     import DependencyRateMetric
 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
+from opencensus.ext.azure.metrics_exporter.standard_metrics.http_requests \
+    import RequestsRateMetric
 
 # List of standard metrics to track
 STANDARD_METRICS = [AvailableMemoryMetric,
                     DependencyRateMetric,
                     ProcessCPUMetric,
                     ProcessMemoryMetric,
-                    ProcessorTimeMetric]
+                    ProcessorTimeMetric,
+                    RequestsRateMetric]
 
 
 def register_metrics():

…_exporter/standard_metrics/dependency.py …rter/standard_metrics/http_dependency.pycontrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics/dependency.py renamed to contrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics/http_dependency.py contrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics/dependency.py renamed to contrib/opencensus-ext-azure/opencensus/ext/azure/metrics_exporter/standard_metrics/http_dependency.py

@@ -76,7 +76,7 @@ def __call__(self):
         value over the elapsed time.
 
         :rtype: :class:`opencensus.metrics.export.gauge.DerivedLongGauge`
-        :return: The gauge representing the available memory metric
+        :return: The gauge representing the outgoing requests metric
         """
         gauge = DerivedDoubleGauge(
             DependencyRateMetric.NAME,

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

@@ -0,0 +1,109 @@
+# 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 sys
+import time
+
+from opencensus.metrics.export.gauge import DerivedDoubleGauge
+if sys.version_info < (3,):
+    from BaseHTTPServer import HTTPServer
+else:
+    from http.server import HTTPServer
+
+requests_map = dict()
+ORIGINAL_CONSTRUCTOR = HTTPServer.__init__
+
+
+def request_patch(func):
+    def wrapper(self=None):
+        func(self)
+        count = requests_map.get('count', 0)
+        requests_map['count'] = count + 1
+    return wrapper
+
+
+def server_patch(*args, **kwargs):
+    if len(args) >= 3:
+        handler = args[2]
+        if handler:
+            # Patch the handler methods if they exist
+            if "do_DELETE" in dir(handler):
+                handler.do_DELETE = request_patch(handler.do_DELETE)
+            if "do_GET" in dir(handler):
+                handler.do_GET = request_patch(handler.do_GET)
+            if "do_HEAD" in dir(handler):
+                handler.do_HEAD = request_patch(handler.do_HEAD)
+            if "do_OPTIONS" in dir(handler):
+                handler.do_OPTIONS = request_patch(handler.do_OPTIONS)
+            if "do_POST" in dir(handler):
+                handler.do_POST = request_patch(handler.do_POST)
+            if "do_PUT" in dir(handler):
+                handler.do_PUT = request_patch(handler.do_PUT)
+    result = ORIGINAL_CONSTRUCTOR(*args, **kwargs)
+    return result
+
+
+def setup():
+    # Patch the HTTPServer handler to track request information
+    HTTPServer.__init__ = server_patch
+
+
+class RequestsRateMetric(object):
+    NAME = "\\ASP.NET Applications(??APP_W3SVC_PROC??)\\Requests/Sec"
+
+    def __init__(self):
+        setup()
+
+    @staticmethod
+    def get_value():
+        current_count = requests_map.get('count', 0)
+        current_time = time.time()
+        last_count = requests_map.get('last_count', 0)
+        last_time = requests_map.get('last_time')
+        last_result = requests_map.get('last_result', 0)
+
+        try:
+            # last_time is None the very first time this function is called
+            if last_time is not None:
+                elapsed_seconds = current_time - last_time
+                interval_count = current_count - last_count
+                result = interval_count / elapsed_seconds
+            else:
+                result = 0
+            requests_map['last_time'] = current_time
+            requests_map['last_count'] = current_count
+            requests_map['last_result'] = result
+            return result
+        except ZeroDivisionError:
+            # If elapsed_seconds is 0, exporter call made too close to previous
+            # Return the previous result if this is the case
+            return last_result
+
+    def __call__(self):
+        """ Returns a derived gauge for incoming requests per second
+
+        Calculated by obtaining by getting the number of incoming requests
+        made to an HTTPServer within an elapsed time and dividing that value
+        over the elapsed time.
+
+        :rtype: :class:`opencensus.metrics.export.gauge.DerivedLongGauge`
+        :return: The gauge representing the incoming requests metric
+        """
+        gauge = DerivedDoubleGauge(
+            RequestsRateMetric.NAME,
+            'Incoming Requests per second',
+            'rps',
+            [])
+        gauge.create_default_time_series(RequestsRateMetric.get_value)
+        return gauge

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

@@ -15,19 +15,27 @@
 import collections
 import mock
 import requests
+import sys
 import unittest
 
 from opencensus.ext.azure.metrics_exporter import standard_metrics
 from opencensus.trace import execution_context
+if sys.version_info < (3,):
+    from BaseHTTPServer import HTTPServer
+else:
+    from http.server import HTTPServer
 
 ORIGINAL_FUNCTION = requests.Session.request
+ORIGINAL_CONS = HTTPServer.__init__
 
 
 class TestStandardMetrics(unittest.TestCase):
     def setUp(self):
-        standard_metrics.dependency.dependency_map.clear()
+        standard_metrics.http_dependency.dependency_map.clear()
+        standard_metrics.http_requests.requests_map.clear()
         requests.Session.request = ORIGINAL_FUNCTION
-        standard_metrics.dependency.ORIGINAL_REQUEST = ORIGINAL_FUNCTION
+        standard_metrics.http_dependency.ORIGINAL_REQUEST = ORIGINAL_FUNCTION
+        standard_metrics.http_requests.ORIGINAL_CONSTRUCTOR = ORIGINAL_CONS
 
     @mock.patch('opencensus.ext.azure.metrics_exporter'
                 '.standard_metrics.register_metrics')
@@ -40,12 +48,12 @@ def test_producer_get_metrics(self):
         producer = standard_metrics.AzureStandardMetricsProducer()
         metrics = producer.get_metrics()
 
-        self.assertEqual(len(metrics), 5)
+        self.assertEqual(len(metrics), 6)
 
     def test_register_metrics(self):
         registry = standard_metrics.register_metrics()
 
-        self.assertEqual(len(registry.get_metrics()), 5)
+        self.assertEqual(len(registry.get_metrics()), 6)
 
     def test_get_available_memory_metric(self):
         metric = standard_metrics.AvailableMemoryMetric()
@@ -135,21 +143,21 @@ def test_get_process_cpu_usage_exception(self, logger_mock):
             logger_mock.exception.assert_called()
 
     def test_dependency_patch(self):
-        map = standard_metrics.dependency.dependency_map
-        standard_metrics.dependency.ORIGINAL_REQUEST = lambda x: None
+        map = standard_metrics.http_dependency.dependency_map
+        standard_metrics.http_dependency.ORIGINAL_REQUEST = lambda x: None
         session = requests.Session()
         execution_context.set_is_exporter(False)
-        result = standard_metrics.dependency.dependency_patch(session)
+        result = standard_metrics.http_dependency.dependency_patch(session)
 
         self.assertEqual(map['count'], 1)
         self.assertIsNone(result)
 
     def test_dependency_patch_exporter_thread(self):
-        map = standard_metrics.dependency.dependency_map
-        standard_metrics.dependency.ORIGINAL_REQUEST = lambda x: None
+        map = standard_metrics.http_dependency.dependency_map
+        standard_metrics.http_dependency.ORIGINAL_REQUEST = lambda x: None
         session = mock.Mock()
         execution_context.set_is_exporter(True)
-        result = standard_metrics.dependency.dependency_patch(session)
+        result = standard_metrics.http_dependency.dependency_patch(session)
 
         self.assertIsNone(map.get('count'))
         self.assertIsNone(result)
@@ -167,21 +175,126 @@ def test_get_dependency_rate_first_time(self):
         self.assertEqual(rate, 0)
 
     @mock.patch('opencensus.ext.azure.metrics_exporter'
-                '.standard_metrics.dependency.time')
+                '.standard_metrics.http_dependency.time')
     def test_get_dependency_rate(self, time_mock):
         time_mock.time.return_value = 100
-        standard_metrics.dependency.dependency_map['last_time'] = 98
-        standard_metrics.dependency.dependency_map['count'] = 4
+        standard_metrics.http_dependency.dependency_map['last_time'] = 98
+        standard_metrics.http_dependency.dependency_map['count'] = 4
         rate = standard_metrics.DependencyRateMetric.get_value()
 
         self.assertEqual(rate, 2)
 
     @mock.patch('opencensus.ext.azure.metrics_exporter'
-                '.standard_metrics.dependency.time')
+                '.standard_metrics.http_dependency.time')
     def test_get_dependency_rate_error(self, time_mock):
         time_mock.time.return_value = 100
-        standard_metrics.dependency.dependency_map['last_result'] = 5
-        standard_metrics.dependency.dependency_map['last_time'] = 100
+        standard_metrics.http_dependency.dependency_map['last_result'] = 5
+        standard_metrics.http_dependency.dependency_map['last_time'] = 100
         result = standard_metrics.DependencyRateMetric.get_value()
 
         self.assertEqual(result, 5)
+
+    def test_request_patch(self):
+        map = standard_metrics.http_requests.requests_map
+        func = mock.Mock()
+        new_func = standard_metrics.http_requests.request_patch(func)
+        new_func()
+
+        self.assertEqual(map['count'], 1)
+        self.assertEqual(len(func.call_args_list), 1)
+
+    def test_server_patch(self):
+        standard_metrics. \
+            http_requests. \
+            ORIGINAL_CONSTRUCTOR = lambda x, y, z: None
+        with mock.patch('opencensus.ext.azure.metrics_exporter'
+                        '.standard_metrics.http_requests'
+                        '.request_patch') as request_mock:
+            handler = mock.Mock()
+            handler.do_DELETE.return_value = None
+            handler.do_GET.return_value = None
+            handler.do_HEAD.return_value = None
+            handler.do_OPTIONS.return_value = None
+            handler.do_POST.return_value = None
+            handler.do_PUT.return_value = None
+            result = standard_metrics. \
+                http_requests. \
+                server_patch(None, None, handler)
+            handler.do_DELETE()
+            handler.do_GET()
+            handler.do_HEAD()
+            handler.do_OPTIONS()
+            handler.do_POST()
+            handler.do_PUT()
+
+            self.assertEqual(result, None)
+            self.assertEqual(len(request_mock.call_args_list), 6)
+
+    def test_server_patch_no_methods(self):
+        standard_metrics. \
+            http_requests. \
+            ORIGINAL_CONSTRUCTOR = lambda x, y, z: None
+        with mock.patch('opencensus.ext.azure.metrics_exporter'
+                        '.standard_metrics.http_requests'
+                        '.request_patch') as request_mock:
+            handler = mock.Mock()
+            result = standard_metrics. \
+                http_requests. \
+                server_patch(None, None, handler)
+            handler.do_DELETE()
+            handler.do_GET()
+            handler.do_HEAD()
+            handler.do_OPTIONS()
+            handler.do_POST()
+            handler.do_PUT()
+
+            self.assertEqual(result, None)
+            self.assertEqual(len(request_mock.call_args_list), 0)
+
+    def test_server_patch_no_args(self):
+        standard_metrics \
+            .http_requests \
+            .ORIGINAL_CONSTRUCTOR = lambda x, y: None
+        r = standard_metrics.http_requests.server_patch(None, None)
+
+        self.assertEqual(r, None)
+
+    def test_server_patch_no_handler(self):
+        standard_metrics \
+            .http_requests \
+            .ORIGINAL_CONSTRUCTOR = lambda x, y, z: None
+        r = standard_metrics.http_requests.server_patch(None, None, None)
+
+        self.assertEqual(r, None)
+
+    def test_get_request_rate_metric(self):
+        metric = standard_metrics.RequestsRateMetric()
+        gauge = metric()
+
+        name = '\\ASP.NET Applications(??APP_W3SVC_PROC??)\\Requests/Sec'
+        self.assertEqual(gauge.descriptor.name, name)
+
+    def test_get_request_rate_first_time(self):
+        rate = standard_metrics.RequestsRateMetric.get_value()
+
+        self.assertEqual(rate, 0)
+
+    @mock.patch('opencensus.ext.azure.metrics_exporter'
+                '.standard_metrics.http_requests.time')
+    def test_get_request_rate(self, time_mock):
+        time_mock.time.return_value = 100
+        standard_metrics.http_requests.requests_map['last_time'] = 98
+        standard_metrics.http_requests.requests_map['count'] = 4
+        rate = standard_metrics.RequestsRateMetric.get_value()
+
+        self.assertEqual(rate, 2)
+
+    @mock.patch('opencensus.ext.azure.metrics_exporter'
+                '.standard_metrics.http_requests.time')
+    def test_get_request_rate_error(self, time_mock):
+        time_mock.time.return_value = 100
+        standard_metrics.http_requests.requests_map['last_result'] = 5
+        standard_metrics.http_requests.requests_map['last_time'] = 100
+        result = standard_metrics.RequestsRateMetric.get_value()
+
+        self.assertEqual(result, 5)