Merge pull request #45 from flask-dashboard/development

Development

Author: mircealungu

README.md

@@ -9,6 +9,8 @@ You can see the execution time and last access time per endpoint.
 
 Also, unit tests can be run by TravisCI and monitored.
 
+IMPORTANT: Since the implementation uses string interpolation, the minimum python version is 3.6 [PEP 498](https://www.python.org/dev/peps/pep-0498/).
+
 Installation
 ============
 To install from source, download the source code, then run this:
@@ -27,7 +29,7 @@ Adding the extension to your flask app is simple:
     import dashboard
 
     user_app = Flask(__name__)
-    dashboard.config.from_file('/<path to your config file>/config.cfg')
+    dashboard.config.init_from(file='/<path to your config file>/config.cfg')
 
     def get_session_id():
         # Implement your own function for obtaining the user variable here.
@@ -36,6 +38,11 @@ Adding the extension to your flask app is simple:
     dashboard.config.get_group_by = get_session_id
     dashboard.bind(app=user_app)
 
+Instead of having a hardcoded string containing the location of the config file in the code above, it is also possible 
+to define an environment variable that specifies the location of this config file.
+The line should then be `dashboard.config.init_from(envvar='DASHBOARD_CONFIG')`. This will configure the dashboard based on the file 
+provided in the environment variable called `DASHBOARD_CONFIG`.
+    
 Usage
 =====
 Once the setup is done, a config file ('config.cfg') should be set next to the python file that contains the entry point of the app.
@@ -51,7 +58,6 @@ The following things can be configured:
     DATABASE=sqlite:////<path to your project>/dashboard.db
     GIT=/<path to your project>/.git/
     TEST_DIR=/<path to your project>/tests/
-    LOG_DIR=/<path to your project>/
     N=5
     SUBMIT_RESULTS_URL=http://0.0.0.0:5000/dashboard/submit-test-results
     OUTLIER_DETECTION_CONSTANT=2.5
@@ -65,23 +71,34 @@ When running your app, the dashboard van be viewed by default in the route:
 
 TravisCI unit testing
 =====================
-To enable Travis to run your unit tests and send the results to the dashboard, four steps have to be taken.
-
-First off, the file 'collect_performance.py' (which comes with the dashboard) should be copied to the directory where your '.travis.yml' file resides.
+To enable Travis to run your unit tests and send the results to the dashboard, four steps have to be taken:
 
-Secondly, your config file for the dashboard ('config.cfg') should be updated to include four additional values, TEST_DIR, LOG_DIR, SUBMIT_RESULTS_URL and N.
-The first specifies where your unit tests reside, the second where the logs should be placed, the third where Travis should upload the test results to, and the last specifies the number of times Travis should run each unit test.
-See the sample config file in the section above for an example.
+1. Update the config file ('config.cfg') to include three additional values, TEST_DIR, SUBMIT_RESULTS_URL and N.
+    - TEST_DIR specifies where the unit tests reside.
+    - SUBMIT_RESULTS_URL specifies where Travis should upload the test results to. When left out, the results will not
+    be sent anywhere, but the performance collection process will still run.
+    - N specifies the number of times Travis should run each unit test. 
 
-Then, the installation requirement for the dashboard has to be added to the 'setup.py' file of your app:
+2. The installation requirement for the dashboard has to be added to the 'setup.py' file of your app:
 
+    dependency_links=["https://github.com/flask-dashboard/Flask-Monitoring-Dashboard/tarball/master#egg=flask_monitoring_dashboard"]
+    
     install_requires=('flask_monitoring_dashboard')
 
-Lastly, in your '.travis.yml' file, two script commands should be added:
+3. In your '.travis.yml' file, three script commands should be added:
 
     script:
-      - export DASHBOARD_CONFIG=config.cfg
-      - python ./collect_performance.py
+      - export DASHBOARD_CONFIG=./config.cfg
+      - export DASHBOARD_LOG_DIR=./logs/
+      - python -m dashboard.collect_performance
+
+   The config environment variable specifies where the performance collection process can find the config file.
+The log directory environment variable specifies where the performance collection process should place the logs it uses.
+The third command will start the actual performance collection process.
+
+4. A method that is executed after every request should be added to the blueprint of your app. 
+This is done by the dashboard automatically when the blueprint is passed to the binding function like so: `dashboard.bind(app=app, blue_print=api)`.
+This extra method is needed for the logging, and without it, the unit test results cannot be grouped by endpoint that they test.
 
 Screenshots
 ===========

dashboard/__init__.py

@@ -30,16 +30,32 @@ def loc():
 blueprint = Blueprint('dashboard', __name__, template_folder=loc() + 'templates')
 
 
-def bind(app):
+def bind(app, blue_print=None):
     """
         Binding the app to this object should happen before importing the routing-
         methods below. Thus, the importing statement is part of this function.
-        :param app: the app for which the performance has to be tracked    
+        :param app: the app for which the performance has to be tracked
+        :param blue_print: the blueprint that contains the endpoints to be monitored
     """
     assert app is not None
     global user_app, blueprint
     user_app = app
 
+    if blue_print:
+        import os
+        import datetime
+        from flask import request
+        log_dir = os.getenv('DASHBOARD_LOG_DIR')
+
+        @blue_print.after_request
+        def after_request(response):
+            if log_dir:
+                t1 = str(datetime.datetime.now())
+                log = open(log_dir + "endpoint_hits.log", "a")
+                log.write("\"{}\",\"{}\"\n".format(t1, request.endpoint))
+                log.close()
+            return response
+
     # Add all route-functions to the blueprint
     import dashboard.routings
 
@@ -49,17 +65,3 @@ def bind(app):
 
     # register the blueprint to the app
     app.register_blueprint(blueprint, url_prefix='/' + config.link)
-
-    # search for tests if test dir specified
-    if config.test_dir:
-        from dashboard.database.tests import add_test, get_tests
-        suites = TestLoader().discover(config.test_dir, pattern="*test*.py")
-        existing_tests = get_tests()
-        tests = []
-        for t in existing_tests:
-            tests.append(t.name)
-        for suite in suites:
-            for case in suite:
-                for test in case:
-                    if str(test) not in tests:
-                        add_test(str(test))

dashboard/collect_performance.py

@@ -14,8 +14,16 @@
     print('Please set an environment variable \'DASHBOARD_CONFIG\' specifying the absolute path to your config file.')
     sys.exit(0)
 
+# Abort if log directory is not specified.
+log_dir = os.getenv('DASHBOARD_LOG_DIR')
+if log_dir is None:
+    print('You must specify a log directory for the dashboard to be able to use the unit test monitoring functionality.')
+    print('Please set an environment variable \'DASHBOARD_LOG_DIR\' specifying the absolute path where you want the log files to be placed.')
+    sys.exit(0)
+
 n = 1
 url = None
+sys.path.insert(0, os.getcwd())
 parser = configparser.RawConfigParser()
 try:
     parser.read(config)
@@ -26,9 +34,6 @@
     else:
         print('No test directory specified in your config file. Please do so.')
         sys.exit(0)
-    if not parser.has_option('dashboard', 'LOG_DIR'):
-        print('No log directory specified in your config file. Please do so.')
-        sys.exit(0)
     if parser.has_option('dashboard', 'SUBMIT_RESULTS_URL'):
         url = parser.get('dashboard', 'SUBMIT_RESULTS_URL')
     else:
@@ -37,7 +42,10 @@
     print("Something went wrong while parsing the configuration file:\n{}".format(e))
 
 data = {'test_runs': [], 'grouped_tests': []}
-log = open("test_runs.log", "w")
+log = open(log_dir + "endpoint_hits.log", "w")
+log.write("\"time\",\"endpoint\"\n")
+log.close()
+log = open(log_dir + "test_runs.log", "w")
 log.write("\"start_time\",\"stop_time\",\"test_name\"\n")
 
 if test_dir:
@@ -61,7 +69,7 @@
 
 # Read and parse the log containing the test runs
 runs = []
-with open('test_runs.log') as log:
+with open(log_dir + 'test_runs.log') as log:
     reader = csv.DictReader(log)
     for row in reader:
         runs.append([datetime.datetime.strptime(row["start_time"], "%Y-%m-%d %H:%M:%S.%f"),
@@ -70,7 +78,7 @@
 
 # Read and parse the log containing the endpoint hits
 hits = []
-with open('endpoint_hits.log') as log:
+with open(log_dir + 'endpoint_hits.log') as log:
     reader = csv.DictReader(log)
     for row in reader:
         hits.append([datetime.datetime.strptime(row["time"], "%Y-%m-%d %H:%M:%S.%f"),

dashboard/config.py

@@ -23,12 +23,12 @@ def __init__(self):
         self.guest_password = ['guest_password']
         self.outlier_detection_constant = 2.5
         self.colors = {}
-        self.log_dir = None
+        self.security_token = 'cc83733cb0af8b884ff6577086b87909'
 
         # define a custom function to retrieve the session_id or username
         self.get_group_by = None
 
-    def from_file(self, config_file):
+    def init_from(self, file=None, envvar=None):
         """
             The config_file must at least contains the following variables in section 'dashboard':
             APP_VERSION: the version of the app that you use. Updating the version helps in 
@@ -54,16 +54,28 @@ def from_file(self, config_file):
                 average, extra information is logged into the database. A default value for this
                 variable is 2.5, but can be changed in the config-file.
 
-            :param config_file: a string pointing to the location of the config-file
+            SECURITY_TOKEN: Used for getting the data in /get_json_data/<security_token>
+
+            :param file: a string pointing to the location of the config-file
+            :param envvar: a string specifying which environment variable holds the config file location
         """
 
-        config = os.getenv('DASHBOARD_CONFIG')
-        if config:
-            config_file = config
+        if envvar:
+            file = os.getenv(envvar)
+        if not file:
+            print("No configuration file specified. Please do so.")
+
+
+        # When collecting unit test performance results, create log file
+        log_dir = os.getenv('DASHBOARD_LOG_DIR')
+        if log_dir:
+            log = open(log_dir + "endpoint_hits.log", "w")
+            log.write("\"time\",\"endpoint\"\n")
+            log.close()
 
         parser = configparser.RawConfigParser()
         try:
-            parser.read(config_file)
+            parser.read(file)
             if parser.has_option('dashboard', 'APP_VERSION'):
                 self.version = parser.get('dashboard', 'APP_VERSION')
             if parser.has_option('dashboard', 'CUSTOM_LINK'):
@@ -72,11 +84,6 @@ def from_file(self, config_file):
                 self.database_name = parser.get('dashboard', 'DATABASE')
             if parser.has_option('dashboard', 'TEST_DIR'):
                 self.test_dir = parser.get('dashboard', 'TEST_DIR')
-            if parser.has_option('dashboard', 'LOG_DIR'):
-                self.log_dir = parser.get('dashboard', 'LOG_DIR')
-                log = open(self.log_dir + "endpoint_hits.log", "w")
-                log.write("\"time\",\"endpoint\"\n")
-                log.close()
 
             # For manually defining colors of specific endpoints
             if parser.has_option('dashboard', 'COLORS'):
@@ -113,5 +120,10 @@ def from_file(self, config_file):
             if parser.has_option('dashboard', 'OUTLIER_DETECTION_CONSTANT'):
                 self.outlier_detection_constant = ast.literal_eval(
                     parser.get('dashboard', 'OUTLIER_DETECTION_CONSTANT'))
+
+            # when a security token is provided:
+            if parser.has_option('dashboard', 'security_token'):
+                self.security_token = parser.get('dashboard', 'SECURITY_TOKEN')
+
         except configparser.Error:
             raise

dashboard/database/function_calls.py

@@ -3,10 +3,10 @@
 """
 
 from flask import request
-from sqlalchemy import func, desc, text, asc
+from sqlalchemy import func, desc, text, asc, DateTime
 from dashboard import config
 import datetime
-from dashboard.database import session_scope, FunctionCall
+from dashboard.database import session_scope, FunctionCall, MonitorRule
 from dashboard.colors import get_color
 
 
@@ -48,19 +48,30 @@ def get_times():
         return result
 
 
-def get_data():
-    """ Returns all data in the FunctionCall table, for the export data option. """
+def get_data_from(time_from):
+    """
+        Returns all data in the FunctionCall table, for the export data option.
+        This function returns all data after the time_from date.
+    """
     with session_scope() as db_session:
         result = db_session.query(FunctionCall.endpoint,
                                   FunctionCall.execution_time,
                                   FunctionCall.time,
                                   FunctionCall.version,
                                   FunctionCall.group_by,
-                                  FunctionCall.ip).all()
+                                  FunctionCall.ip).filter(FunctionCall.time >= time_from)
         db_session.expunge_all()
         return result
 
 
+def get_data():
+    """
+    Equivalent function to get_data_from, but returns all data.
+    :return: all data from the database in the Endpoint-table.
+    """
+    return get_data_from(datetime.date(1970, 1, 1))
+
+
 def get_data_per_version(version):
     """ Returns all data in the FuctionCall table, grouped by their version. """
     with session_scope() as db_session:

dashboard/database/monitor_rules.py

@@ -12,7 +12,31 @@ def get_monitor_rules():
         return result
 
 
+def get_monitor_names():
+    """ Return all names of monitor rules that are currently being monitored"""
+    with session_scope() as db_session:
+        result = db_session.query(MonitorRule.endpoint).filter(MonitorRule.monitor).all()
+        db_session.expunge_all()
+        return result
+
+
 def reset_monitor_endpoints():
     """ Update all monitor rules in the database and set them to false. """
     with session_scope() as db_session:
         db_session.query(MonitorRule).update({MonitorRule.monitor: False})
+
+
+def get_monitor_data():
+    """
+    Returns all data in the rules-table. This table contains which endpoints are being
+    monitored and which are not.
+    :return: all data from the database in the rules-table.
+    """
+    with session_scope() as db_session:
+        result = db_session.query(MonitorRule.endpoint,
+                                  MonitorRule.last_accessed,
+                                  MonitorRule.monitor,
+                                  MonitorRule.time_added,
+                                  MonitorRule.version_added).all()
+        db_session.expunge_all()
+        return result

dashboard/main.py

@@ -1,10 +1,15 @@
+"""
+    This file can be executed for developing purposes. It is not used, when the flask_monitoring_dashboard is
+    attached to an existing flask application.
+"""
+
 from flask import Flask, redirect, url_for
 import dashboard
 import os
 
 user_app = Flask(__name__)
 here = os.path.abspath(os.path.dirname(__file__))
-dashboard.config.from_file(here + '/config.cfg')
+dashboard.config.init_from(file=here + '/config.cfg')
 
 
 def get_session_id():

dashboard/measurement.py

@@ -55,19 +55,12 @@ def wrapper(*args, **kwargs):
             # start a thread to log the stacktrace after 'average' ms
             stack_info = StackInfo(average)
 
-        t1 = str(datetime.datetime.now())
         time1 = time.time()
         result = func(*args, **kwargs)
         time2 = time.time()
         t = (time2 - time1) * 1000
         add_function_call(time=t, endpoint=endpoint)
 
-        # Logging for grouping unit test results by endpoint
-        if config.log_dir:
-            log = open(config.log_dir + "endpoint_hits.log", "a")
-            log.write("\"{}\",\"{}\"\n".format(t1, endpoint))
-            log.close()
-
         # outlier detection
         endpoint_count[endpoint] += 1
         endpoint_sum[endpoint] += t